constree 0.1.6 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +479 -12
  3. data/lib/constree/node.rb +20 -5
  4. data/lib/constree/version.rb +1 -1
  5. metadata +3 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 91bc646f95fa84573ef59c5c7ae36cba758a46481dcc1a33c42aecc190fd35f8
4
- data.tar.gz: fc31388a1493bade700bba3144ab67cea1a484e89812b8cc8dfa0a63b7c5da01
3
+ metadata.gz: bdccf3b020fb9b2b3a5c599bab8e5acedf62f08b8ed77b7f6afcdb9dbee7e074
4
+ data.tar.gz: 85c983124f2990e636e60ddddbe05fc19519a11bf3d9a69d63a3b416b35be6b9
5
5
  SHA512:
6
- metadata.gz: 2859b1ada05e4933b59b597f60f6c05283720544fe101b7aed7d9781dd0ee6f3bc891b217333706ae384b83e67a300e883529b242ce3d6c988f6b693023e2492
7
- data.tar.gz: 2bcae5e18331f0a84084d5e90822e32c82a7f110a83a2152050e3d77a14da0d04843c6ba052dab6cc2b976f3d964cab540ec52605019f2bd75303bc6fd5cf609
6
+ metadata.gz: f4162527720c2ba191a1b8cd7668100c43767e10935d3ec7eba79a77f4b90991d60d0e59390546fd0aa4745cb58cd623d6cd3b05c8ffc1bc7b8b7a22da424b5c
7
+ data.tar.gz: 1159cfc11945b68a73533552e6f019873da48a42930f1d37b6a42147e031542a366f6c51e2d7bdd5f869661263f6ffa7c1546ee2292f00d59236bf0317d0ae26
data/README.md CHANGED
@@ -21,20 +21,487 @@ Or install it yourself as:
21
21
  ## Example: constants in Minitest::Spec
22
22
 
23
23
  ```ruby
24
- irb(main):001:0> require 'minitest/spec'
24
+ irb(main):001:0> require "concurrent-ruby"
25
25
  => true
26
26
  irb(main):002:0> Constree.p Minitest::Spec
27
- Minitest::Spec < Minitest::Spec::DSL::InstanceMethods < Minitest::Test < Minitest::Guard < Minitest::Test::LifecycleHooks < Minitest::Reportable < Minitest::Assertions < Minitest::Runnable < Object < Minitest::Expectations < Kernel < BasicObject
28
- ├─DSL (Module)
29
- │ ├─InstanceMethods (Module)
30
- │ └─TYPES (Array)
31
- ├─TYPES → Minitest::Spec::DSL::TYPES
32
- ├─PASSTHROUGH_EXCEPTIONS (Array)
33
- ├─TEARDOWN_METHODS (Array)
34
- ├─LifecycleHooks (Module)
35
- ├─E (String)
36
- ├─UNDEFINED (Object)
37
- └─SIGNALS (Hash)
27
+ Concurrent {:kla=>Module}
28
+ ├─AbstractExchanger {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
29
+ │ └─ClassMethods {:kla=>Module}
30
+ ├─AbstractExecutorService {:kla=>Class, :aft=>[Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
31
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
32
+ │ ├─DEBUG {:kla=>Integer}
33
+ │ ├─ERROR {:kla=>Integer}
34
+ │ ├─FALLBACK_POLICIES {:kla=>Array}
35
+ │ ├─FATAL {:kla=>Integer}
36
+ │ ├─INFO {:kla=>Integer}
37
+ │ ├─UNKNOWN {:kla=>Integer}
38
+ │ └─WARN {:kla=>Integer}
39
+ ├─AbstractThreadLocalVar {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
40
+ ├─Agent {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
41
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
42
+ │ ├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
43
+ │ └─ValidationError {:kla=>Class, :aft=>[Concurrent::Agent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
44
+ ├─Array {:kla=>Class, :aft=>[Array, Enumerable, Object, Kernel, BasicObject]}
45
+ ├─Async {:kla=>Module}
46
+ ├─Atom {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
47
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
48
+ ├─AtomicBoolean {:kla=>Class, :aft=>[Concurrent::MutexAtomicBoolean, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
49
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
50
+ ├─AtomicDirectUpdate {:kla=>Module}
51
+ ├─AtomicFixnum {:kla=>Class, :aft=>[Concurrent::MutexAtomicFixnum, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
52
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
53
+ ├─AtomicMarkableReference {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
54
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
55
+ ├─AtomicNumericCompareAndSetWrapper {:kla=>Module}
56
+ ├─AtomicReference {:kla=>Class, :aft=>[Concurrent::MutexAtomicReference, Concurrent::AtomicNumericCompareAndSetWrapper, Concurrent::AtomicDirectUpdate, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
57
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
58
+ ├─CRubySet {:kla=>Class, :aft=>[Set, Enumerable, Object, Kernel, BasicObject]}
59
+ │ └─InspectKey {:kla=>Symbol}
60
+ ├─CachedThreadPool {:kla=>Class, :aft=>[Concurrent::ThreadPoolExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
61
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
62
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
63
+ │ ├─DEFAULT_MAX_POOL_SIZE {:kla=>Integer}
64
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
65
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
66
+ │ ├─DEFAULT_SYNCHRONOUS {:kla=>FalseClass}
67
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:kla=>Integer}
68
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
69
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
70
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
71
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
72
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
73
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
74
+ ├─CancelledOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
75
+ ├─Collection {:kla=>Module}
76
+ │ ├─CopyOnNotifyObserverSet {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
77
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
78
+ │ ├─CopyOnWriteObserverSet {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
79
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
80
+ │ ├─MapImplementation {:kla=>Class, :aft=>[Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
81
+ │ ├─MriMapBackend {:ref=>"Concurrent::Collection::MapImplementation"}
82
+ │ ├─NonConcurrentMapBackend {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
83
+ │ ├─NonConcurrentPriorityQueue {:kla=>Class, :aft=>[Concurrent::Collection::RubyNonConcurrentPriorityQueue, Object, Kernel, BasicObject]}
84
+ │ └─RubyNonConcurrentPriorityQueue {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
85
+ ├─Concern {:kla=>Module}
86
+ │ ├─Deprecation {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
87
+ │ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
88
+ │ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
89
+ │ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
90
+ │ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
91
+ │ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
92
+ │ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
93
+ │ ├─Dereferenceable {:kla=>Module}
94
+ │ ├─Logging {:kla=>Module, :aft=>[Logger::Severity]}
95
+ │ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
96
+ │ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
97
+ │ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
98
+ │ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
99
+ │ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
100
+ │ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
101
+ │ ├─Obligation {:kla=>Module, :aft=>[Concurrent::Concern::Dereferenceable]}
102
+ │ └─Observable {:kla=>Module}
103
+ ├─ConcurrentUpdateError {:kla=>Class, :aft=>[ThreadError, StandardError, Exception, Object, Kernel, BasicObject]}
104
+ │ └─CONC_UP_ERR_BACKTRACE {:kla=>Array}
105
+ ├─ConfigurationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
106
+ ├─CountDownLatch {:kla=>Class, :aft=>[Concurrent::MutexCountDownLatch, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
107
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
108
+ ├─CyclicBarrier {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
109
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
110
+ ├─Delay {:kla=>Class, :aft=>[Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
111
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
112
+ ├─DependencyCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
113
+ ├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
114
+ ├─Event {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
115
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
116
+ ├─Exchanger {:kla=>Class, :aft=>[Concurrent::RubyExchanger, Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
117
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
118
+ ├─ExecutorService {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
119
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
120
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
121
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
122
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
123
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
124
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
125
+ ├─FixedThreadPool {:kla=>Class, :aft=>[Concurrent::ThreadPoolExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
126
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
127
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
128
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
129
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
130
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
131
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
132
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
133
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
134
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
135
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
136
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
137
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
138
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
139
+ ├─Future {:kla=>Class, :aft=>[Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
140
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
141
+ ├─Hash {:kla=>Class, :aft=>[Hash, Enumerable, Object, Kernel, BasicObject]}
142
+ ├─IVar {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
143
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
144
+ ├─IllegalOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
145
+ ├─ImmediateExecutor {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
146
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
147
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
148
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
149
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
150
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
151
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
152
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
153
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
154
+ ├─ImmutabilityError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
155
+ ├─ImmutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
156
+ ├─IndirectImmediateExecutor {:kla=>Class, :aft=>[Concurrent::ImmediateExecutor, Concurrent::SerialExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
157
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
158
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
159
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
160
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
161
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
162
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
163
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
164
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
165
+ ├─InitializationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
166
+ ├─LifecycleError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
167
+ ├─LockFreeStack {:kla=>Class, :aft=>[Enumerable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
168
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
169
+ │ ├─EMPTY {:kla=>Concurrent::LockFreeStack::Node}
170
+ │ └─Node {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
171
+ ├─MVar {:kla=>Class, :aft=>[Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
172
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
173
+ │ ├─EMPTY {:kla=>Object}
174
+ │ └─TIMEOUT {:kla=>Object}
175
+ ├─Map {:kla=>Class, :aft=>[Concurrent::Collection::MriMapBackend, Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
176
+ ├─MaxRestartFrequencyError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
177
+ ├─Maybe {:kla=>Class, :aft=>[Comparable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
178
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
179
+ │ └─NONE {:kla=>Object}
180
+ ├─MultipleAssignmentError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
181
+ ├─MultipleErrors {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
182
+ ├─MutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
183
+ ├─MutexAtomicBoolean {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
184
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
185
+ ├─MutexAtomicFixnum {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
186
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
187
+ ├─MutexAtomicReference {:kla=>Class, :aft=>[Concurrent::AtomicNumericCompareAndSetWrapper, Concurrent::AtomicDirectUpdate, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
188
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
189
+ ├─MutexCountDownLatch {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
190
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
191
+ ├─MutexSemaphore {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
192
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
193
+ ├─NULL {:kla=>Object}
194
+ ├─NULL_LOGGER {:kla=>Proc}
195
+ ├─Options {:kla=>Module}
196
+ ├─Promise {:kla=>Class, :aft=>[Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
197
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
198
+ ├─PromiseExecutionError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
199
+ ├─Promises {:kla=>Module}
200
+ │ ├─AbstractEventFuture {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
201
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
202
+ │ │ ├─Fulfilled {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
203
+ │ │ ├─FulfilledArray {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Fulfilled, Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
204
+ │ │ ├─PENDING {:kla=>Concurrent::Promises::InternalStates::Pending}
205
+ │ │ ├─PartiallyRejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
206
+ │ │ ├─Pending {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
207
+ │ │ ├─RESERVED {:kla=>Concurrent::Promises::InternalStates::Reserved}
208
+ │ │ ├─RESOLVED {:kla=>Concurrent::Promises::InternalStates::Fulfilled}
209
+ │ │ ├─Rejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
210
+ │ │ ├─Reserved {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Pending, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
211
+ │ │ ├─ResolvedWithResult {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
212
+ │ │ └─State {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
213
+ │ ├─Event {:kla=>Class, :aft=>[Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
214
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
215
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
216
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
217
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
218
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
219
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
220
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
221
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
222
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
223
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
224
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
225
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
226
+ │ ├─FactoryMethods {:kla=>Module, :aft=>[Concurrent::Promises::FactoryMethods::Configuration]}
227
+ │ │ └─Configuration {:kla=>Module}
228
+ │ ├─Future {:kla=>Class, :aft=>[Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
229
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
230
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
231
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
232
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
233
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
234
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
235
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
236
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
237
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
238
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
239
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
240
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
241
+ │ ├─Resolvable {:kla=>Module, :aft=>[Concurrent::Promises::InternalStates]}
242
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
243
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
244
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
245
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
246
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
247
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
248
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
249
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
250
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
251
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
252
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
253
+ │ ├─ResolvableEvent {:kla=>Class, :aft=>[Concurrent::Promises::Resolvable, Concurrent::Promises::Event, Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
254
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
255
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
256
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
257
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
258
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
259
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
260
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
261
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
262
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
263
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
264
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
265
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
266
+ │ └─ResolvableFuture {:kla=>Class, :aft=>[Concurrent::Promises::Resolvable, Concurrent::Promises::Future, Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
267
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
268
+ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
269
+ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
270
+ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
271
+ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
272
+ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
273
+ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
274
+ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
275
+ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
276
+ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
277
+ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
278
+ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
279
+ ├─ReInclude {:kla=>Module}
280
+ ├─ReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
281
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
282
+ │ ├─MAX_READERS {:kla=>Integer}
283
+ │ ├─MAX_WRITERS {:kla=>Integer}
284
+ │ ├─RUNNING_WRITER {:kla=>Integer}
285
+ │ └─WAITING_WRITER {:kla=>Integer}
286
+ ├─ReentrantReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
287
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
288
+ │ ├─MAX_READERS {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
289
+ │ ├─MAX_WRITERS {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
290
+ │ ├─READER_BITS {:kla=>Integer}
291
+ │ ├─READ_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
292
+ │ ├─RUNNING_WRITER {:ref=>"Concurrent::ReadWriteLock::RUNNING_WRITER"}
293
+ │ ├─WAITING_WRITER {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
294
+ │ ├─WRITER_BITS {:kla=>Integer}
295
+ │ ├─WRITE_LOCK_HELD {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
296
+ │ └─WRITE_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
297
+ ├─RejectedExecutionError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
298
+ ├─ResourceLimitError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
299
+ ├─RubyExchanger {:kla=>Class, :aft=>[Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
300
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
301
+ ├─RubyExecutorService {:kla=>Class, :aft=>[Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
302
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
303
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
304
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
305
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
306
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
307
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
308
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
309
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
310
+ ├─RubySingleThreadExecutor {:kla=>Class, :aft=>[Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
311
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
312
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
313
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
314
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
315
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
316
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
317
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
318
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
319
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
320
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
321
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
322
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
323
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
324
+ ├─RubyThreadLocalVar {:kla=>Class, :aft=>[Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
325
+ ├─RubyThreadPoolExecutor {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
326
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
327
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
328
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
329
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
330
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
331
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
332
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
333
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
334
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
335
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
336
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
337
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
338
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
339
+ ├─SafeTaskExecutor {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
340
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
341
+ ├─ScheduledTask {:kla=>Class, :aft=>[Comparable, Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
342
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
343
+ ├─Semaphore {:kla=>Class, :aft=>[Concurrent::MutexSemaphore, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
344
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
345
+ ├─SerialExecutorService {:kla=>Module, :aft=>[Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity]}
346
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
347
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
348
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
349
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
350
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
351
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
352
+ ├─SerializedExecution {:kla=>Class, :aft=>[Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
353
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
354
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
355
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
356
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
357
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
358
+ │ ├─Job {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
359
+ │ │ ├─Group {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
360
+ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
361
+ │ │ │ ├─Passwd {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
362
+ │ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
363
+ │ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
364
+ │ │ │ │ └─Tms {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
365
+ │ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
366
+ │ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
367
+ │ │ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
368
+ │ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
369
+ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
370
+ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
371
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
372
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
373
+ ├─SerializedExecutionDelegator {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
374
+ │ ├─BasicObject {:kla=>Class}
375
+ │ │ └─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
376
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
377
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
378
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
379
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
380
+ │ ├─RUBYGEMS_ACTIVATION_MONITOR {:kla=>Monitor}
381
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
382
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
383
+ ├─Set {:kla=>Class, :aft=>[Concurrent::CRubySet, Set, Enumerable, Object, Kernel, BasicObject]}
384
+ │ └─InspectKey {:ref=>"Concurrent::CRubySet::InspectKey"}
385
+ ├─SettableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
386
+ ├─SimpleExecutorService {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
387
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
388
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
389
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
390
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
391
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
392
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
393
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
394
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
395
+ ├─SingleThreadExecutor {:kla=>Class, :aft=>[Concurrent::RubySingleThreadExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
396
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
397
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
398
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
399
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
400
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
401
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
402
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
403
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
404
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
405
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
406
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
407
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
408
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
409
+ ├─Synchronization {:kla=>Module}
410
+ │ ├─AbstractLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
411
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
412
+ │ ├─AbstractObject {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
413
+ │ ├─AbstractStruct {:kla=>Module}
414
+ │ ├─Condition {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
415
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
416
+ │ ├─ConditionSignalling {:kla=>Module}
417
+ │ ├─Lock {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
418
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
419
+ │ ├─LockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
420
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
421
+ │ ├─MonitorLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
422
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
423
+ │ ├─MriAttrVolatile {:kla=>Module}
424
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
425
+ │ ├─MriObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
426
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
427
+ │ ├─MutexLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
428
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
429
+ │ ├─Object {:kla=>Class, :aft=>[Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
430
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
431
+ │ ├─RbxAttrVolatile {:kla=>Module}
432
+ │ │ └─ClassMethods {:kla=>Module}
433
+ │ ├─RbxLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
434
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
435
+ │ ├─RbxObject {:kla=>Class, :aft=>[Concurrent::Synchronization::RbxAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
436
+ │ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::RbxAttrVolatile::ClassMethods"}
437
+ │ ├─TruffleRubyAttrVolatile {:kla=>Module}
438
+ │ │ └─ClassMethods {:kla=>Module}
439
+ │ ├─TruffleRubyObject {:kla=>Class, :aft=>[Concurrent::Synchronization::TruffleRubyAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
440
+ │ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods"}
441
+ │ └─Volatile {:ref=>"Concurrent::Synchronization::MriAttrVolatile"}
442
+ ├─SynchronizedDelegator {:kla=>Class, :aft=>[SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
443
+ │ ├─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
444
+ │ └─RUBYGEMS_ACTIVATION_MONITOR {:ref=>"Concurrent::SerializedExecutionDelegator::RUBYGEMS_ACTIVATION_MONITOR"}
445
+ ├─TVar {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
446
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
447
+ ├─ThreadLocalVar {:kla=>Class, :aft=>[Concurrent::RubyThreadLocalVar, Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
448
+ ├─ThreadPoolExecutor {:kla=>Class, :aft=>[Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
449
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
450
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
451
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
452
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
453
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
454
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
455
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
456
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
457
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
458
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
459
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
460
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
461
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
462
+ ├─ThreadSafe {:kla=>Module}
463
+ │ └─Util {:kla=>Module}
464
+ │ ├─CPU_COUNT {:kla=>Integer}
465
+ │ ├─FIXNUM_BIT_SIZE {:kla=>Integer}
466
+ │ └─MAX_INT {:kla=>Integer}
467
+ ├─TimeoutError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
468
+ ├─TimerSet {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
469
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
470
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
471
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
472
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
473
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
474
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
475
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
476
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
477
+ ├─TimerTask {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Concern::Dereferenceable, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
478
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
479
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
480
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
481
+ │ ├─EXECUTION_INTERVAL {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
482
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
483
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
484
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
485
+ │ ├─TIMEOUT_INTERVAL {:kla=>Integer}
486
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
487
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
488
+ ├─Transaction {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
489
+ │ ├─ABORTED {:kla=>Object}
490
+ │ ├─AbortError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
491
+ │ ├─LeaveError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
492
+ │ └─OpenEntry {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
493
+ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
494
+ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
495
+ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
496
+ ├─Tuple {:kla=>Class, :aft=>[Enumerable, Object, Kernel, BasicObject]}
497
+ ├─Utility {:kla=>Module}
498
+ │ ├─EngineDetector {:kla=>Module}
499
+ │ ├─NativeExtensionLoader {:kla=>Module}
500
+ │ ├─NativeInteger {:kla=>Module}
501
+ │ │ ├─MAX_VALUE {:ref=>"Concurrent::ThreadSafe::Util::MAX_INT"}
502
+ │ │ └─MIN_VALUE {:kla=>Integer}
503
+ │ └─ProcessorCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
504
+ └─VERSION {:kla=>String}
38
505
  => nil
39
506
  ```
40
507
 
data/lib/constree/node.rb CHANGED
@@ -6,7 +6,7 @@ module Constree
6
6
  include TreeGraph
7
7
 
8
8
  def label_for_tree_graph
9
- display_name + ' ' + type
9
+ "#{display_name} #{verbose}"
10
10
  end
11
11
 
12
12
  def children_for_tree_graph
@@ -17,8 +17,9 @@ module Constree
17
17
 
18
18
  def sub_nodes
19
19
  return [] unless constant.is_a? Module
20
- constant.constants.map do |name|
21
- Node.new(constant.const_get(name), name, self)
20
+ constant.constants.sort!.map! do |name|
21
+ const_value = constant.const_get(name)
22
+ Node.new(const_value, name, self)
22
23
  end
23
24
  end
24
25
 
@@ -39,8 +40,22 @@ module Constree
39
40
  constant == other.constant
40
41
  end
41
42
 
42
- def type
43
- ref ? "→ #{ref.full_name}" : "(#{constant.class.to_s})"
43
+ def verbose
44
+ return {ref: ref.full_name} if ref
45
+
46
+ info = {kla: constant.class}
47
+ return info unless constant.is_a? Module
48
+
49
+ ancestors = constant.ancestors
50
+ idx = ancestors.index(constant)
51
+ if idx > 0 && !(before = ancestors[0 .. (idx - 1)]).empty?
52
+ info[:bef] = before
53
+ end
54
+ unless (after = ancestors[(idx + 1) .. -1]).empty?
55
+ info[:aft] = after
56
+ end
57
+
58
+ info
44
59
  end
45
60
 
46
61
  def not_yet? seen
data/lib/constree/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module Constree
2
- VERSION = "0.1.6"
2
+ VERSION = "0.1.7"
3
3
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: constree
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.6
4
+ version: 0.1.7
5
5
  platform: ruby
6
6
  authors:
7
7
  - ken
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2021-10-05 00:00:00.000000000 Z
11
+ date: 2022-12-10 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
106
106
  - !ruby/object:Gem::Version
107
107
  version: '0'
108
108
  requirements: []
109
- rubygems_version: 3.2.3
109
+ rubygems_version: 3.1.6
110
110
  signing_key:
111
111
  specification_version: 4
112
112
  summary: recursively show the structure of constants in a module