TEST_CODEOWNERS/rails
3
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Define a convention for descendants and subclasses.

Browse Source 
The former should be symmetric with ancestors and include all children. However, it should not include self since ancestors + descendants should not have duplicated. The latter is symmetric to superclass in the sense it only includes direct children.

By adopting a convention, we expect to have less conflict with other frameworks, as Datamapper. For this moment, to ensure ActiveModel::Validations can be used with Datamapper, we should always call ActiveSupport::DescendantsTracker.descendants(self) internally instead of self.descendants avoiding conflicts.
This commit is contained in:
José Valim 2010-07-05 12:50:08 +02:00
parent 5bf3294c8b
commit a5dda97602
13 changed files with 103 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
actionpack/lib/action_controller/base.rb
View File

@ -60,17 +60,11 @@ def self.without_modules(*modules)
include ActionController::Compatibility
def self.inherited(klass)
::ActionController::Base.subclasses << klass.to_s
super
klass.helper :all
end
def self.subclasses
@subclasses ||= []
end
config_accessor :asset_host, :asset_path
ActiveSupport.run_load_hooks(:action_controller, self)
end
end

1
actionpack/lib/action_controller/railtie.rb
View File

@ -2,7 +2,6 @@
require "action_controller"
require "action_dispatch/railtie"
require "action_view/railtie"
require "active_support/core_ext/class/subclasses"
require "active_support/deprecation/proxy_wrappers"
require "active_support/deprecation"

4
actionpack/lib/action_dispatch/routing/deprecated_mapper.rb
View File

@ -19,8 +19,8 @@ def controller_constraints
def in_memory_controller_namespaces
namespaces = Set.new
ActionController::Base.subclasses.each do |klass|
controller_name = klass.underscore
ActionController::Base.descendants.each do |klass|
controller_name = klass.name.underscore
namespaces << controller_name.split('/')[0...-1].join('/')
end
namespaces.delete('')

6
activerecord/lib/active_record/observer.rb
View File

@ -94,7 +94,7 @@ class Observer < ActiveModel::Observer
def initialize
super
observed_subclasses.each { |klass| add_observer!(klass) }
observed_descendants.each { |klass| add_observer!(klass) }
end
def self.method_added(method)
@ -108,8 +108,8 @@ def self.method_added(method)
protected
def observed_subclasses
observed_classes.sum([]) { |klass| klass.send(:descendants) }
def observed_descendants
observed_classes.sum([]) { |klass| klass.descendants }
end
def observe_callbacks?

4
activesupport/lib/active_support/callbacks.rb
View File

@ -432,7 +432,7 @@ def __update_callbacks(name, filters = [], block = nil) #:nodoc:
options = filters.last.is_a?(Hash) ? filters.pop : {}
filters.unshift(block) if block
([self] + self.descendants).each do |target|
([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |target|
chain = target.send("_#{name}_callbacks")
yield chain, type, filters, options
target.__define_runner(name)
@ -506,7 +506,7 @@ def skip_callback(name, *filter_list, &block)
def reset_callbacks(symbol)
callbacks = send("_#{symbol}_callbacks")
self.descendants.each do |target|
ActiveSupport::DescendantsTracker.descendants(self).each do |target|
chain = target.send("_#{symbol}_callbacks")
callbacks.each { |c| chain.delete(c) }
target.__define_runner(symbol)

57
activesupport/lib/active_support/core_ext/class/subclasses.rb
View File

@ -2,54 +2,49 @@
require 'active_support/core_ext/module/reachable'
class Class #:nodoc:
# Returns an array with the names of the subclasses of +self+ as strings.
#
# Integer.subclasses # => ["Bignum", "Fixnum"]
def subclasses
Class.subclasses_of(self).map { |o| o.to_s }
end
# Rubinius
if defined?(Class.__subclasses__)
alias :subclasses :__subclasses__
def descendants
subclasses = []
__subclasses__.each {|k| subclasses << k; subclasses.concat k.descendants }
subclasses
descendants = []
__subclasses__.each do |k|
descendants << k
descendants.concat k.descendants
end
descendants
end
else
# MRI
else # MRI
begin
ObjectSpace.each_object(Class.new) {}
def descendants
subclasses = []
descendants = []
ObjectSpace.each_object(class << self; self; end) do |k|
subclasses << k unless k == self
descendants.unshift k unless k == self
end
subclasses
descendants
end
# JRuby
rescue StandardError
rescue StandardError # JRuby
def descendants
subclasses = []
descendants = []
ObjectSpace.each_object(Class) do |k|
subclasses << k if k < self
descendants.unshift k if k < self
end
subclasses.uniq!
subclasses
descendants.uniq!
descendants
end
end
end
# 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.
def self.subclasses_of(*superclasses) #:nodoc:
subclasses = []
superclasses.each do |klass|
subclasses.concat klass.descendants.select {|k| k.anonymous? || k.reachable?}
# Returns an array with the direct children of +self+.
#
# Integer.subclasses # => [Bignum, Fixnum]
def subclasses
subclasses, chain = [], descendants
chain.each do |k|
subclasses << k unless chain.any? { |c| c > k }
end
subclasses
end
subclasses
end
end

1
activesupport/lib/active_support/core_ext/object.rb
View File

@ -6,7 +6,6 @@
require 'active_support/core_ext/object/conversions'
require 'active_support/core_ext/object/instance_variables'
require 'active_support/core_ext/object/misc'
require 'active_support/core_ext/object/extending'
require 'active_support/core_ext/object/returning'
require 'active_support/core_ext/object/to_json'

11
activesupport/lib/active_support/core_ext/object/extending.rb
View File

@ -1,11 +0,0 @@
require 'active_support/core_ext/class/subclasses'
class 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.
def subclasses_of(*superclasses) #:nodoc:
Class.subclasses_of(*superclasses)
end
end

24
activesupport/lib/active_support/descendants_tracker.rb
View File

@ -4,16 +4,23 @@ module ActiveSupport
# This module provides an internal implementation to track descendants
# which is faster than iterating through ObjectSpace.
module DescendantsTracker
@@descendants = Hash.new { |h, k| h[k] = [] }
@@direct_descendants = Hash.new { |h, k| h[k] = [] }
def self.descendants
@@descendants
def self.direct_descendants(klass)
@@direct_descendants[klass]
end
def self.descendants(klass)
@@direct_descendants[klass].inject([]) do |descendants, klass|
descendants << klass
descendants.concat klass.descendants
end
end
def self.clear
@@descendants.each do |klass, descendants|
@@direct_descendants.each do |klass, descendants|
if ActiveSupport::Dependencies.autoloaded?(klass)
@@descendants.delete(klass)
@@direct_descendants.delete(klass)
else
descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
end
@ -26,14 +33,11 @@ def inherited(base)
end
def direct_descendants
@@descendants[self]
DescendantsTracker.direct_descendants(self)
end
def descendants
@@descendants[self].inject([]) do |descendants, klass|
descendants << klass
descendants.concat klass.descendants
end
DescendantsTracker.descendants(self)
end
end
end

46
activesupport/test/core_ext/class_test.rb
View File

@ -1,29 +1,27 @@
require 'abstract_unit'
require 'active_support/core_ext/class'
class A
end
module X
class B
end
end
module Y
module Z
class C
end
end
end
class ClassTest < Test::Unit::TestCase
def test_retrieving_subclasses
@parent = eval("class D; end; D")
@sub = eval("class E < D; end; E")
@subofsub = eval("class F < E; end; F")
assert_equal 2, @parent.subclasses.size
assert_equal [@subofsub.to_s], @sub.subclasses
assert_equal [], @subofsub.subclasses
assert_equal [@sub.to_s, @subofsub.to_s].sort, @parent.subclasses.sort
class Parent; end
class Foo < Parent; end
class Bar < Foo; end
class Baz < Bar; end
class A < Parent; end
class B < A; end
class C < B; end
def test_descendants
assert_equal [Foo, Bar, Baz, A, B, C], Parent.descendants
assert_equal [Bar, Baz], Foo.descendants
assert_equal [Baz], Bar.descendants
assert_equal [], Baz.descendants
end
end
def test_subclasses
assert_equal [Foo, A], Parent.subclasses
assert_equal [Bar], Foo.subclasses
assert_equal [Baz], Bar.subclasses
assert_equal [], Baz.subclasses
end
end

49
activesupport/test/core_ext/object_and_class_ext_test.rb
View File

@ -40,55 +40,6 @@ class Foo
include Bar
end
class ClassExtTest < Test::Unit::TestCase
def test_subclasses_of_should_find_nested_classes
assert Class.subclasses_of(ClassK).include?(Nested::ClassL)
end
def test_subclasses_of_should_not_return_removed_classes
# First create the removed class
old_class = Nested.class_eval { remove_const :ClassL }
new_class = Class.new(ClassK)
Nested.const_set :ClassL, new_class
assert_equal "Nested::ClassL", new_class.name # Sanity check
subclasses = Class.subclasses_of(ClassK)
assert subclasses.include?(new_class)
assert ! subclasses.include?(old_class)
ensure
Nested.const_set :ClassL, old_class unless defined?(Nested::ClassL)
end
def test_subclasses_of_should_not_trigger_const_missing
const_missing = false
Nested.on_const_missing { const_missing = true }
subclasses = Class.subclasses_of ClassK
assert !const_missing
assert_equal [ Nested::ClassL ], subclasses
removed = Nested.class_eval { remove_const :ClassL } # keep it in memory
subclasses = Class.subclasses_of ClassK
assert !const_missing
assert subclasses.empty?
ensure
Nested.const_set :ClassL, removed unless defined?(Nested::ClassL)
end
def test_subclasses_of_with_multiple_roots
classes = Class.subclasses_of(ClassI, ClassK)
assert_equal %w(ClassJ Nested::ClassL), classes.collect(&:to_s).sort
end
def test_subclasses_of_doesnt_find_anonymous_classes
assert_equal [], Class.subclasses_of(Foo)
bar = Class.new(Foo)
assert_nothing_raised do
assert_equal [bar], Class.subclasses_of(Foo)
end
end
end
class ObjectTests < ActiveSupport::TestCase
class DuckTime
def acts_like_time?

8
activesupport/test/descendants_tracker_test.rb
View File

@ -37,7 +37,9 @@ def test_direct_descendants
def test_clear_with_autoloaded_parent_children_and_granchildren
mark_as_autoloaded(*ALL) do
ActiveSupport::DescendantsTracker.clear
assert ActiveSupport::DescendantsTracker.descendants.slice(*ALL).empty?
ALL.each do |k|
assert ActiveSupport::DescendantsTracker.descendants(k).empty?
end
end
end
@ -64,12 +66,12 @@ def mark_as_autoloaded(*klasses)
old_autoloaded = ActiveSupport::Dependencies.autoloaded_constants.dup
ActiveSupport::Dependencies.autoloaded_constants = klasses.map(&:name)
old_descendants = ActiveSupport::DescendantsTracker.descendants.dup
old_descendants = ActiveSupport::DescendantsTracker.class_eval("@@direct_descendants").dup
old_descendants.each { |k, v| old_descendants[k] = v.dup }
yield
ensure
ActiveSupport::Dependencies.autoloaded_constants = old_autoloaded
ActiveSupport::DescendantsTracker.descendants.replace(old_descendants)
ActiveSupport::DescendantsTracker.class_eval("@@direct_descendants").replace(old_descendants)
end
end

81
railties/guides/source/active_support_core_extensions.textile
View File

@ -387,40 +387,6 @@ TIP: Since +with_options+ forwards calls to its receiver they can be nested. Eac
NOTE: Defined in +active_support/core_ext/object/with_options.rb+.
h5. +subclasses_of+
The method +subclasses_of+ receives an arbitrary number of class objects and returns all their anonymous or reachable descendants as a single array:
<ruby>
class C; end
subclasses_of(C) # => []
subclasses_of(Integer) # => [Bignum, Fixnum]
module M
class A; end
class B1 < A; end
class B2 < A; end
end
module N
class C < M::B1; end
end
subclasses_of(M::A) # => [N::C, M::B2, M::B1]
</ruby>
The order in which these classes are returned is unspecified. The returned collection may have duplicates:
<ruby>
subclasses_of(Numeric, Integer)
# => [Bignum, Float, Fixnum, Integer, Date::Infinity, Rational, BigDecimal, Bignum, Fixnum]
</ruby>
See also +Class#subclasses+ in "Extensions to +Class+ FIX THIS LINK":FIXME.
NOTE: Defined in +active_support/core_ext/object/extending.rb+.
h4. Instance Variables
Active Support provides several methods to ease access to instance variables.
@ -1141,36 +1107,47 @@ If for whatever reason an application loads the definition of a mailer class and
NOTE: Defined in +active_support/core_ext/class/delegating_attributes.rb+.
h4. Descendants
h4. Descendants & Subclasses
h5. +subclasses+
h5. +descendants+
The +subclasses+ method returns the names of all the anonymous or reachable descendants of its receiver as an array of strings:
The +descendants+ method returns all classes, including its children, that inherits from self.
<ruby>
class C; end
C.subclasses # => []
C.descendants #=> []
Integer.subclasses # => ["Bignum", "Fixnum"]
class B < C; end
C.descendants #=> [B]
module M
class A; end
class B1 < A; end
class B2 < A; end
end
class A < B; end
C.descendants #=> [B, A]
module N
class C < M::B1; end
end
M::A.subclasses # => ["N::C", "M::B2", "M::B1"]
class D < C; end
C.descendants #=> [B, A, D]
</ruby>
The order in which these class names are returned is unspecified.
h5. +subclasses+
See also +Object#subclasses_of+ in "Extensions to All Objects FIX THIS LINK":FIXME.
The +subclasses+ method returns all direct classes that inherits from self.
WARNING: This method is redefined in some Rails core classes.
<ruby>
class C; end
C.subclasses #=> []
class B < C; end
C.subclasses #=> [B]
class A < B; end
C.subclasses #=> [B]
class D < C; end
C.subclasses #=> [B, D]
</ruby>
The order in which these class are returned is unspecified.
WARNING: This method is redefined in some Rails core classes but should be all compatible in Rails 3.1.
NOTE: Defined in +active_support/core_ext/class/subclasses.rb+.