constree 0.1.6 → 0.1.8

Sign up to get free protection for your applications and to get access to all the features.
Files changed (7) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +489 -14
  3. data/constree.gemspec +1 -0
  4. data/lib/constree/node.rb +34 -5
  5. data/lib/constree/version.rb +1 -1
  6. data/lib/constree.rb +4 -0
  7. metadata +17 -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: fda87378a074ec894ad39ea09eff44fe458f6ea5ad208b9a53ff097a07c2d8b8
4
+ data.tar.gz: e2b0d100fdfac4da1ab1eedec5eb1efc98383de15a55a67aa642a34601505d7c
5
5
  SHA512:
6
- metadata.gz: 2859b1ada05e4933b59b597f60f6c05283720544fe101b7aed7d9781dd0ee6f3bc891b217333706ae384b83e67a300e883529b242ce3d6c988f6b693023e2492
7
- data.tar.gz: 2bcae5e18331f0a84084d5e90822e32c82a7f110a83a2152050e3d77a14da0d04843c6ba052dab6cc2b976f3d964cab540ec52605019f2bd75303bc6fd5cf609
6
+ metadata.gz: 833f161b42abd52f8193281c0236b19b5b72edfe8738a28e73861611ab15cdab1733846b4d70fc625dc14b32100ca17085021a4c7298f9a6904881e34ee39622
7
+ data.tar.gz: b6558cc98fc60be4e1e6c0701abc56cfdabe8c549b89f7f96938aa238caa0849618945061a7fce1270e2799d5b0b278f717592d7c72eaff8e5b99f8cfa8ae58e
data/README.md CHANGED
@@ -18,23 +18,498 @@ Or install it yourself as:
18
18
 
19
19
  $ gem install constree
20
20
 
21
- ## Example: constants in Minitest::Spec
21
+ ## Example: output tree to html
22
22
 
23
23
  ```ruby
24
- irb(main):001:0> require 'minitest/spec'
24
+ File.open('somewhere', 'w') do |f|
25
+ f.puts Constree.html_of SomeConstant
26
+ end
27
+ ```
28
+
29
+ ## Example: check constants in concurrent-ruby, in irb console
30
+
31
+ ```ruby
32
+ irb(main):001:0> require "concurrent-ruby"
25
33
  => true
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)
34
+ irb(main):002:0> Constree.p Concurrent
35
+ Concurrent {:kla=>Module}
36
+ ├─AbstractExchanger {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
37
+ │ └─ClassMethods {:kla=>Module}
38
+ ├─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]}
39
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
40
+ │ ├─DEBUG {:kla=>Integer}
41
+ │ ├─ERROR {:kla=>Integer}
42
+ │ ├─FALLBACK_POLICIES {:kla=>Array}
43
+ │ ├─FATAL {:kla=>Integer}
44
+ │ ├─INFO {:kla=>Integer}
45
+ │ ├─UNKNOWN {:kla=>Integer}
46
+ │ └─WARN {:kla=>Integer}
47
+ ├─AbstractThreadLocalVar {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
48
+ ├─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]}
49
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
50
+ │ ├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
51
+ │ └─ValidationError {:kla=>Class, :aft=>[Concurrent::Agent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
52
+ ├─Array {:kla=>Class, :aft=>[Array, Enumerable, Object, Kernel, BasicObject]}
53
+ ├─Async {:kla=>Module}
54
+ ├─Atom {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
55
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
56
+ ├─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]}
57
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
58
+ ├─AtomicDirectUpdate {:kla=>Module}
59
+ ├─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]}
60
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
61
+ ├─AtomicMarkableReference {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
62
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
63
+ ├─AtomicNumericCompareAndSetWrapper {:kla=>Module}
64
+ ├─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]}
65
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
66
+ ├─CRubySet {:kla=>Class, :aft=>[Set, Enumerable, Object, Kernel, BasicObject]}
67
+ │ └─InspectKey {:kla=>Symbol}
68
+ ├─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]}
69
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
70
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
71
+ │ ├─DEFAULT_MAX_POOL_SIZE {:kla=>Integer}
72
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
73
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
74
+ │ ├─DEFAULT_SYNCHRONOUS {:kla=>FalseClass}
75
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:kla=>Integer}
76
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
77
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
78
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
79
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
80
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
81
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
82
+ ├─CancelledOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
83
+ ├─Collection {:kla=>Module}
84
+ │ ├─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]}
85
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
86
+ │ ├─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]}
87
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
88
+ │ ├─MapImplementation {:kla=>Class, :aft=>[Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
89
+ │ ├─MriMapBackend {:ref=>"Concurrent::Collection::MapImplementation"}
90
+ │ ├─NonConcurrentMapBackend {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
91
+ │ ├─NonConcurrentPriorityQueue {:kla=>Class, :aft=>[Concurrent::Collection::RubyNonConcurrentPriorityQueue, Object, Kernel, BasicObject]}
92
+ │ └─RubyNonConcurrentPriorityQueue {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
93
+ ├─Concern {:kla=>Module}
94
+ │ ├─Deprecation {:kla=>Module, :aft=>[Concurrent::Concern::Logging, 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
+ │ ├─Dereferenceable {:kla=>Module}
102
+ │ ├─Logging {:kla=>Module, :aft=>[Logger::Severity]}
103
+ │ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
104
+ │ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
105
+ │ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
106
+ │ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
107
+ │ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
108
+ │ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
109
+ │ ├─Obligation {:kla=>Module, :aft=>[Concurrent::Concern::Dereferenceable]}
110
+ │ └─Observable {:kla=>Module}
111
+ ├─ConcurrentUpdateError {:kla=>Class, :aft=>[ThreadError, StandardError, Exception, Object, Kernel, BasicObject]}
112
+ │ └─CONC_UP_ERR_BACKTRACE {:kla=>Array}
113
+ ├─ConfigurationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
114
+ ├─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]}
115
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
116
+ ├─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]}
117
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
118
+ ├─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]}
119
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
120
+ ├─DependencyCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
121
+ ├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
122
+ ├─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]}
123
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
124
+ ├─Exchanger {:kla=>Class, :aft=>[Concurrent::RubyExchanger, Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
125
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
126
+ ├─ExecutorService {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
127
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
128
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
129
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
130
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
131
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
132
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
133
+ ├─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]}
134
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
135
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
136
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
137
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
138
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
139
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
140
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
141
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
142
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
143
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
144
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
145
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
146
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
147
+ ├─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]}
148
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
149
+ ├─Hash {:kla=>Class, :aft=>[Hash, Enumerable, Object, Kernel, BasicObject]}
150
+ ├─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]}
151
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
152
+ ├─IllegalOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
153
+ ├─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]}
154
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
155
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
156
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
157
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
158
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
159
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
160
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
161
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
162
+ ├─ImmutabilityError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
163
+ ├─ImmutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
164
+ ├─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]}
165
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
166
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
167
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
168
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
169
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
170
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
171
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
172
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
173
+ ├─InitializationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
174
+ ├─LifecycleError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
175
+ ├─LockFreeStack {:kla=>Class, :aft=>[Enumerable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
176
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
177
+ │ ├─EMPTY {:kla=>Concurrent::LockFreeStack::Node}
178
+ │ └─Node {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
179
+ ├─MVar {:kla=>Class, :aft=>[Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
180
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
181
+ │ ├─EMPTY {:kla=>Object}
182
+ │ └─TIMEOUT {:kla=>Object}
183
+ ├─Map {:kla=>Class, :aft=>[Concurrent::Collection::MriMapBackend, Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
184
+ ├─MaxRestartFrequencyError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
185
+ ├─Maybe {:kla=>Class, :aft=>[Comparable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
186
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
187
+ │ └─NONE {:kla=>Object}
188
+ ├─MultipleAssignmentError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
189
+ ├─MultipleErrors {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
190
+ ├─MutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
191
+ ├─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]}
192
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
193
+ ├─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]}
194
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
195
+ ├─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]}
196
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
197
+ ├─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]}
198
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
199
+ ├─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]}
200
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
201
+ ├─NULL {:kla=>Object}
202
+ ├─NULL_LOGGER {:kla=>Proc}
203
+ ├─Options {:kla=>Module}
204
+ ├─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]}
205
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
206
+ ├─PromiseExecutionError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
207
+ ├─Promises {:kla=>Module}
208
+ │ ├─AbstractEventFuture {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
209
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
210
+ │ │ ├─Fulfilled {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
211
+ │ │ ├─FulfilledArray {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Fulfilled, Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
212
+ │ │ ├─PENDING {:kla=>Concurrent::Promises::InternalStates::Pending}
213
+ │ │ ├─PartiallyRejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
214
+ │ │ ├─Pending {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
215
+ │ │ ├─RESERVED {:kla=>Concurrent::Promises::InternalStates::Reserved}
216
+ │ │ ├─RESOLVED {:kla=>Concurrent::Promises::InternalStates::Fulfilled}
217
+ │ │ ├─Rejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
218
+ │ │ ├─Reserved {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Pending, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
219
+ │ │ ├─ResolvedWithResult {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
220
+ │ │ └─State {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
221
+ │ ├─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]}
222
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
223
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
224
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
225
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
226
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
227
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
228
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
229
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
230
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
231
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
232
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
233
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
234
+ │ ├─FactoryMethods {:kla=>Module, :aft=>[Concurrent::Promises::FactoryMethods::Configuration]}
235
+ │ │ └─Configuration {:kla=>Module}
236
+ │ ├─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]}
237
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
238
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
239
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
240
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
241
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
242
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
243
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
244
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
245
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
246
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
247
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
248
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
249
+ │ ├─Resolvable {:kla=>Module, :aft=>[Concurrent::Promises::InternalStates]}
250
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
251
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
252
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
253
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
254
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
255
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
256
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
257
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
258
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
259
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
260
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
261
+ │ ├─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]}
262
+ │ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
263
+ │ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
264
+ │ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
265
+ │ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
266
+ │ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
267
+ │ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
268
+ │ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
269
+ │ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
270
+ │ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
271
+ │ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
272
+ │ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
273
+ │ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
274
+ │ └─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]}
275
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
276
+ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
277
+ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
278
+ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
279
+ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
280
+ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
281
+ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
282
+ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
283
+ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
284
+ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
285
+ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
286
+ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
287
+ ├─ReInclude {:kla=>Module}
288
+ ├─ReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
289
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
290
+ │ ├─MAX_READERS {:kla=>Integer}
291
+ │ ├─MAX_WRITERS {:kla=>Integer}
292
+ │ ├─RUNNING_WRITER {:kla=>Integer}
293
+ │ └─WAITING_WRITER {:kla=>Integer}
294
+ ├─ReentrantReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
295
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
296
+ │ ├─MAX_READERS {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
297
+ │ ├─MAX_WRITERS {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
298
+ │ ├─READER_BITS {:kla=>Integer}
299
+ │ ├─READ_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
300
+ │ ├─RUNNING_WRITER {:ref=>"Concurrent::ReadWriteLock::RUNNING_WRITER"}
301
+ │ ├─WAITING_WRITER {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
302
+ │ ├─WRITER_BITS {:kla=>Integer}
303
+ │ ├─WRITE_LOCK_HELD {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
304
+ │ └─WRITE_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
305
+ ├─RejectedExecutionError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
306
+ ├─ResourceLimitError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
307
+ ├─RubyExchanger {:kla=>Class, :aft=>[Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
308
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
309
+ ├─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]}
310
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
311
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
312
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
313
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
314
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
315
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
316
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
317
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
318
+ ├─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]}
319
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
320
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
321
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
322
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
323
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
324
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
325
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
326
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
327
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
328
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
329
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
330
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
331
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
332
+ ├─RubyThreadLocalVar {:kla=>Class, :aft=>[Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
333
+ ├─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]}
334
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
335
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
336
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
337
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
338
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
339
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
340
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
341
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
342
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
343
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
344
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
345
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
346
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
347
+ ├─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]}
348
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
349
+ ├─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]}
350
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
351
+ ├─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]}
352
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
353
+ ├─SerialExecutorService {:kla=>Module, :aft=>[Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity]}
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
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
359
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
360
+ ├─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]}
361
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
362
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
363
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
364
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
365
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
366
+ │ ├─Job {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
367
+ │ │ ├─Group {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
368
+ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
369
+ │ │ │ ├─Passwd {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
370
+ │ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
371
+ │ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
372
+ │ │ │ │ └─Tms {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
373
+ │ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
374
+ │ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
375
+ │ │ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
376
+ │ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
377
+ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
378
+ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
379
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
380
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
381
+ ├─SerializedExecutionDelegator {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
382
+ │ ├─BasicObject {:kla=>Class}
383
+ │ │ └─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
384
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
385
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
386
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
387
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
388
+ │ ├─RUBYGEMS_ACTIVATION_MONITOR {:kla=>Monitor}
389
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
390
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
391
+ ├─Set {:kla=>Class, :aft=>[Concurrent::CRubySet, Set, Enumerable, Object, Kernel, BasicObject]}
392
+ │ └─InspectKey {:ref=>"Concurrent::CRubySet::InspectKey"}
393
+ ├─SettableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
394
+ ├─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]}
395
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
396
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
397
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
398
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
399
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
400
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
401
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
402
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
403
+ ├─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]}
404
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
405
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
406
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
407
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
408
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
409
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
410
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
411
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
412
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
413
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
414
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
415
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
416
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
417
+ ├─Synchronization {:kla=>Module}
418
+ │ ├─AbstractLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
419
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
420
+ │ ├─AbstractObject {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
421
+ │ ├─AbstractStruct {:kla=>Module}
422
+ │ ├─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]}
423
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
424
+ │ ├─ConditionSignalling {:kla=>Module}
425
+ │ ├─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]}
426
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
427
+ │ ├─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]}
428
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
429
+ │ ├─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]}
430
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
431
+ │ ├─MriAttrVolatile {:kla=>Module}
432
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
433
+ │ ├─MriObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
434
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
435
+ │ ├─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]}
436
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
437
+ │ ├─Object {:kla=>Class, :aft=>[Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
438
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
439
+ │ ├─RbxAttrVolatile {:kla=>Module}
440
+ │ │ └─ClassMethods {:kla=>Module}
441
+ │ ├─RbxLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
442
+ │ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
443
+ │ ├─RbxObject {:kla=>Class, :aft=>[Concurrent::Synchronization::RbxAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
444
+ │ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::RbxAttrVolatile::ClassMethods"}
445
+ │ ├─TruffleRubyAttrVolatile {:kla=>Module}
446
+ │ │ └─ClassMethods {:kla=>Module}
447
+ │ ├─TruffleRubyObject {:kla=>Class, :aft=>[Concurrent::Synchronization::TruffleRubyAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
448
+ │ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods"}
449
+ │ └─Volatile {:ref=>"Concurrent::Synchronization::MriAttrVolatile"}
450
+ ├─SynchronizedDelegator {:kla=>Class, :aft=>[SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
451
+ │ ├─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
452
+ │ └─RUBYGEMS_ACTIVATION_MONITOR {:ref=>"Concurrent::SerializedExecutionDelegator::RUBYGEMS_ACTIVATION_MONITOR"}
453
+ ├─TVar {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
454
+ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
455
+ ├─ThreadLocalVar {:kla=>Class, :aft=>[Concurrent::RubyThreadLocalVar, Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
456
+ ├─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]}
457
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
458
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
459
+ │ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
460
+ │ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
461
+ │ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
462
+ │ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
463
+ │ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
464
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
465
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
466
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
467
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
468
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
469
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
470
+ ├─ThreadSafe {:kla=>Module}
471
+ │ └─Util {:kla=>Module}
472
+ │ ├─CPU_COUNT {:kla=>Integer}
473
+ │ ├─FIXNUM_BIT_SIZE {:kla=>Integer}
474
+ │ └─MAX_INT {:kla=>Integer}
475
+ ├─TimeoutError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
476
+ ├─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]}
477
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
478
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
479
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
480
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
481
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
482
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
483
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
484
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
485
+ ├─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]}
486
+ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
487
+ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
488
+ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
489
+ │ ├─EXECUTION_INTERVAL {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
490
+ │ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
491
+ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
492
+ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
493
+ │ ├─TIMEOUT_INTERVAL {:kla=>Integer}
494
+ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
495
+ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
496
+ ├─Transaction {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
497
+ │ ├─ABORTED {:kla=>Object}
498
+ │ ├─AbortError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
499
+ │ ├─LeaveError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
500
+ │ └─OpenEntry {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
501
+ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
502
+ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
503
+ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
504
+ ├─Tuple {:kla=>Class, :aft=>[Enumerable, Object, Kernel, BasicObject]}
505
+ ├─Utility {:kla=>Module}
506
+ │ ├─EngineDetector {:kla=>Module}
507
+ │ ├─NativeExtensionLoader {:kla=>Module}
508
+ │ ├─NativeInteger {:kla=>Module}
509
+ │ │ ├─MAX_VALUE {:ref=>"Concurrent::ThreadSafe::Util::MAX_INT"}
510
+ │ │ └─MIN_VALUE {:kla=>Integer}
511
+ │ └─ProcessorCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
512
+ └─VERSION {:kla=>String}
38
513
  => nil
39
514
  ```
40
515
 
data/constree.gemspec CHANGED
@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
25
25
  spec.add_development_dependency "minitest", "~> 5.0"
26
26
 
27
27
  spec.add_dependency "tree_graph", "~> 0.2.0"
28
+ spec.add_dependency "tree_html", "~> 0.1.10"
28
29
  end
data/lib/constree/node.rb CHANGED
@@ -1,4 +1,5 @@
1
1
  require 'tree_graph'
2
+ require 'tree_html'
2
3
 
3
4
  module Constree
4
5
  Node = Struct.new :constant, :name, :parent do
@@ -6,19 +7,32 @@ module Constree
6
7
  include TreeGraph
7
8
 
8
9
  def label_for_tree_graph
9
- display_name + ' ' + type
10
+ "#{display_name} #{verbose}"
10
11
  end
11
12
 
12
13
  def children_for_tree_graph
13
14
  @sub_consts ||= []
14
15
  end
15
16
 
17
+ include TreeHtml
18
+
19
+ def label_for_tree_html
20
+ "<span class='hl'>#{display_name}</span> #{verbose}"
21
+ end
22
+
23
+ alias_method :children_for_tree_html, :children_for_tree_graph
24
+
25
+ def css_for_tree_html
26
+ '.hl{color: coral;}'
27
+ end
28
+
16
29
  attr_accessor :ref
17
30
 
18
31
  def sub_nodes
19
32
  return [] unless constant.is_a? Module
20
- constant.constants.map do |name|
21
- Node.new(constant.const_get(name), name, self)
33
+ constant.constants.sort!.map! do |name|
34
+ const_value = constant.const_get(name)
35
+ Node.new(const_value, name, self)
22
36
  end
23
37
  end
24
38
 
@@ -35,12 +49,27 @@ module Constree
35
49
  end
36
50
 
37
51
  def == other
52
+ return false unless constant.is_a? Module
38
53
  return false unless other.is_a? Node
39
54
  constant == other.constant
40
55
  end
41
56
 
42
- def type
43
- ref ? "→ #{ref.full_name}" : "(#{constant.class.to_s})"
57
+ def verbose
58
+ return {ref: ref.full_name} if ref
59
+
60
+ info = {kla: constant.class}
61
+ return info unless constant.is_a? Module
62
+
63
+ ancestors = constant.ancestors
64
+ idx = ancestors.index(constant)
65
+ if idx > 0 && !(before = ancestors[0 .. (idx - 1)]).empty?
66
+ info[:bef] = before
67
+ end
68
+ unless (after = ancestors[(idx + 1) .. -1]).empty?
69
+ info[:aft] = after
70
+ end
71
+
72
+ info
44
73
  end
45
74
 
46
75
  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.8"
3
3
  end
data/lib/constree.rb CHANGED
@@ -22,6 +22,10 @@ module Constree
22
22
  list(mod).first.tree_graph
23
23
  end
24
24
 
25
+ def html_of mod
26
+ list(mod).first.tree_html_full
27
+ end
28
+
25
29
  def p mod
26
30
  puts of mod
27
31
  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.8
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
@@ -66,6 +66,20 @@ dependencies:
66
66
  - - "~>"
67
67
  - !ruby/object:Gem::Version
68
68
  version: 0.2.0
69
+ - !ruby/object:Gem::Dependency
70
+ name: tree_html
71
+ requirement: !ruby/object:Gem::Requirement
72
+ requirements:
73
+ - - "~>"
74
+ - !ruby/object:Gem::Version
75
+ version: 0.1.10
76
+ type: :runtime
77
+ prerelease: false
78
+ version_requirements: !ruby/object:Gem::Requirement
79
+ requirements:
80
+ - - "~>"
81
+ - !ruby/object:Gem::Version
82
+ version: 0.1.10
69
83
  description:
70
84
  email:
71
85
  - block24block@gmail.com
@@ -106,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
106
120
  - !ruby/object:Gem::Version
107
121
  version: '0'
108
122
  requirements: []
109
- rubygems_version: 3.2.3
123
+ rubygems_version: 3.1.6
110
124
  signing_key:
111
125
  specification_version: 4
112
126
  summary: recursively show the structure of constants in a module