raap 0.2.0 → 0.4.0

Sign up to get free protection for your applications and to get access to all the features.
data/lib/raap/type.rb CHANGED
@@ -13,25 +13,37 @@ module RaaP
13
13
 
14
14
  def self.positive_float
15
15
  x = Random.rand
16
- x / Math.sqrt(1 - x * x)
16
+ x / Math.sqrt(1 - (x * x))
17
17
  end
18
18
  end
19
19
 
20
20
  GENERATORS = {}
21
21
  SIMPLE_SOURCE = ('a'..'z').to_a << '_'
22
- RECURSION = Hash.new { |h, k| h[k] = { count: 0, logged: false } }
23
22
 
24
23
  # Type.register "::Integer::positive" { sized { |size| size } }
25
24
  def self.register(type_name, &block)
26
25
  raise ArgumentError, "block is required" unless block
26
+
27
27
  GENERATORS[type_name] = __skip__ = block
28
28
  end
29
29
 
30
+ def self.random
31
+ Type.new("Integer | Float | Rational | Complex | String | Symbol | bool | Encoding | BasicObject | nil | Time")
32
+ end
33
+
34
+ def self.random_without_basic_object
35
+ random.tap do |r|
36
+ # @type var rtype: ::RBS::Types::Union
37
+ rtype = r.type
38
+ rtype.types.reject! { |t| t.to_s == "BasicObject" }
39
+ end
40
+ end
41
+
30
42
  # Special class case
31
43
  register("::Array") do
32
- _type = __skip__ = type
33
- t = _type.args[0] || 'untyped'
34
- array(Type.new(t, range: range))
44
+ instance = __skip__ = type
45
+ t = instance.args[0] ? Type.new(instance.args[0], range:) : Type.random
46
+ array(t)
35
47
  end
36
48
  register("::Binding") { sized { binding } }
37
49
  register("::Complex") { complex }
@@ -40,14 +52,10 @@ module RaaP
40
52
  register("::FalseClass") { sized { false } }
41
53
  register("::Float") { float }
42
54
  register("::Hash") do
43
- sized do |size|
44
- Array.new(integer.pick(size: size).abs).to_h do
45
- _type = __skip__ = type
46
- k = _type.args[0] || 'untyped'
47
- v = _type.args[1] || 'untyped'
48
- [Type.new(k).pick(size: size), Type.new(v).pick(size: size)]
49
- end
50
- end
55
+ instance = __skip__ = type
56
+ key = instance.args[0] ? Type.new(instance.args[0]) : Type.random_without_basic_object
57
+ value = instance.args[1] ? Type.new(instance.args[1]) : Type.random
58
+ dict(key, value)
51
59
  end
52
60
  register("::Integer") { integer }
53
61
  register("::IO") { sized { $stdout } }
@@ -55,11 +63,11 @@ module RaaP
55
63
  register("::NilClass") { sized { nil } }
56
64
  register("::Proc") { sized { Proc.new {} } }
57
65
  register("::Rational") { rational }
58
- register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
66
+ register("::Regexp") { sized { |size| Regexp.new(string.pick(size:)) } }
59
67
  register("::String") { string }
60
68
  register("::Struct") { sized { Struct.new(:foo, :bar).new } }
61
69
  register("::Symbol") { symbol }
62
- register("::Time") { sized { Time.now } }
70
+ register("::Time") { sized { [:call, Time, :now, [], {}, nil] } }
63
71
  register("::TrueClass") { sized { true } }
64
72
  register("::UnboundMethod") { sized { temp_method_object.unbind } }
65
73
 
@@ -79,15 +87,18 @@ module RaaP
79
87
 
80
88
  def sized(&block)
81
89
  Sized.new(&block).tap do |sized|
82
- if s = @such_that
90
+ if (s = @such_that)
83
91
  sized.such_that(&s)
84
92
  end
85
93
  end
86
94
  end
87
95
 
88
- def pick(size: 10, eval: true)
89
- symb = to_symbolic_call(size:)
90
- eval ? SymbolicCaller.new(symb).eval : symb
96
+ def pick(size: 10)
97
+ to_symbolic_caller(size:).eval
98
+ end
99
+
100
+ def to_symbolic_caller(size: 10)
101
+ SymbolicCaller.new(to_symbolic_call(size:))
91
102
  end
92
103
 
93
104
  def to_symbolic_call(size: 10)
@@ -96,20 +107,38 @@ module RaaP
96
107
 
97
108
  case type
98
109
  when ::RBS::Types::Tuple
99
- type.types.map { |t| Type.new(t).pick(size:) }
110
+ type.types.map { |t| Type.new(t).to_symbolic_call(size:) }
100
111
  when ::RBS::Types::Union
101
- type.types.sample&.then { |t| Type.new(t).pick(size:) }
112
+ type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size:) }
102
113
  when ::RBS::Types::Intersection
103
- Value::Intersection.new(type, size: size)
114
+ if type.free_variables.empty?
115
+ [:call, Value::Intersection, :new, [type.to_s], { size: }, nil]
116
+ else
117
+ [:call, Value::Intersection, :new, [type], { size: }, nil]
118
+ end
119
+ when ::RBS::Types::Interface
120
+ if type.free_variables.empty?
121
+ [:call, Value::Interface, :new, [type.to_s], { size: }, nil]
122
+ else
123
+ [:call, Value::Interface, :new, [type], { size: }, nil]
124
+ end
125
+ when ::RBS::Types::Variable
126
+ [:call, Value::Variable, :new, [type.to_s], {}, nil]
127
+ when ::RBS::Types::Bases::Void
128
+ [:call, Value::Void, :new, [], {}, nil]
129
+ when ::RBS::Types::Bases::Top
130
+ [:call, Value::Top, :new, [], {}, nil]
131
+ when ::RBS::Types::Bases::Bottom
132
+ [:call, Value::Bottom, :new, [], {}, nil]
104
133
  when ::RBS::Types::Optional
105
134
  case Random.rand(2)
106
- in 0 then Type.new(type.type).pick(size:)
135
+ in 0 then Type.new(type.type).to_symbolic_call(size: size / 2)
107
136
  in 1 then nil
108
137
  end
109
138
  when ::RBS::Types::Alias
110
139
  case gen = GENERATORS[type.name.absolute!.to_s]
111
140
  in Proc then instance_exec(&gen)
112
- in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).pick(size:)
141
+ in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size:)
113
142
  end
114
143
  when ::RBS::Types::Bases::Class
115
144
  raise "cannot resolve `class` type"
@@ -117,43 +146,33 @@ module RaaP
117
146
  raise "cannot resolve `instance` type"
118
147
  when ::RBS::Types::Bases::Self
119
148
  raise "cannot resolve `self` type"
120
- when ::RBS::Types::Interface
121
- Value::Interface.new(type, size: size)
122
- when ::RBS::Types::Variable
123
- Value::Variable.new(type)
124
149
  when ::RBS::Types::ClassSingleton
125
150
  Object.const_get(type.name.to_s)
126
151
  when ::RBS::Types::ClassInstance
127
152
  case gen = GENERATORS[type.name.absolute!.to_s]
128
- in Proc then instance_exec(&gen).pick(size: size)
129
- in nil then pick_from_initialize(type, size:)
153
+ in Proc then instance_exec(&gen).pick(size:)
154
+ in nil then to_symbolic_call_from_initialize(type, size:)
130
155
  end
131
156
  when ::RBS::Types::Record
132
- type.fields.transform_values { |t| Type.new(t).pick(size:) }
157
+ type.fields.transform_values { |t| Type.new(t).to_symbolic_call(size: size / 2) }
133
158
  when ::RBS::Types::Proc
134
- Proc.new { Type.new(type.type.return_type).pick(size:) }
159
+ Proc.new { Type.new(type.type.return_type).to_symbolic_call(size:) }
135
160
  when ::RBS::Types::Literal
136
161
  type.literal
137
162
  when ::RBS::Types::Bases::Bool
138
- bool.pick(size: size)
139
- when ::RBS::Types::Bases::Void
140
- Value::Void.new
163
+ bool.pick(size:)
141
164
  when ::RBS::Types::Bases::Any
142
- untyped.pick(size: size)
165
+ Type.random.to_symbolic_call(size:)
143
166
  when ::RBS::Types::Bases::Nil
144
167
  nil
145
- when ::RBS::Types::Bases::Top
146
- Value::Top.new
147
- when ::RBS::Types::Bases::Bottom
148
- Value::Bottom.new
149
168
  else
150
- raise "not implemented #{type.to_s}"
169
+ raise "not implemented #{type}"
151
170
  end
152
171
  end
153
172
 
154
173
  private
155
174
 
156
- def pick_from_initialize(type, size:)
175
+ def to_symbolic_call_from_initialize(type, size:)
157
176
  type_name = type.name.absolute!
158
177
  const = Object.const_get(type_name.to_s)
159
178
  definition = RBS.builder.build_singleton(type_name)
@@ -163,13 +182,12 @@ module RaaP
163
182
  rbs_method_type = snew.method_types.sample or raise
164
183
  type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
165
184
  ts = TypeSubstitution.new(type_params, type.args)
166
- maped_rbs_method_type = rbs_method_type
167
185
  maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
168
186
  method_type = MethodType.new(maped_rbs_method_type)
169
187
 
170
188
  begin
171
- try(times: 5, size: size) do |size|
172
- args, kwargs, block = method_type.pick_arguments(size: size, eval: false)
189
+ try(times: 5, size:) do |size|
190
+ args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
173
191
  [:call, const, :new, args, kwargs, block]
174
192
  end
175
193
  rescue
@@ -177,7 +195,7 @@ module RaaP
177
195
  raise
178
196
  end
179
197
  else
180
- Value::Module.new(type)
198
+ [:call, Value::Module, :new, [type.to_s], { size: }, nil]
181
199
  end
182
200
  end
183
201
 
@@ -218,7 +236,7 @@ module RaaP
218
236
  end
219
237
 
220
238
  def integer
221
- sized { |size| float.pick(size: size).round }
239
+ sized { |size| float.pick(size:).round }
222
240
  end
223
241
 
224
242
  def none_zero_integer
@@ -231,9 +249,9 @@ module RaaP
231
249
  in nil, nil
232
250
  Arithmetic.float * size
233
251
  in nil, high
234
- high - Arithmetic.positive_float * size
252
+ high - (Arithmetic.positive_float * size)
235
253
  in low, nil
236
- low + Arithmetic.positive_float * size
254
+ low + (Arithmetic.positive_float * size)
237
255
  in low, high
238
256
  Random.rand(Range.new(low.to_f, high.to_f, @range.exclude_end?))
239
257
  end.round(2)
@@ -242,16 +260,16 @@ module RaaP
242
260
 
243
261
  def rational
244
262
  sized do |size|
245
- a = integer.pick(size: size)
246
- b = none_zero_integer.pick(size: size)
263
+ a = integer.pick(size:)
264
+ b = none_zero_integer.pick(size:)
247
265
  [:call, Kernel, :Rational, [a, b], {}, nil]
248
266
  end
249
267
  end
250
268
 
251
269
  def complex
252
270
  sized do |size|
253
- a = integer.pick(size: size)
254
- b = none_zero_integer.pick(size: size)
271
+ a = integer.pick(size:)
272
+ b = none_zero_integer.pick(size:)
255
273
  [:call, Kernel, :Complex, [a, b], {}, nil]
256
274
  end
257
275
  end
@@ -262,13 +280,11 @@ module RaaP
262
280
  +""
263
281
  else
264
282
  case [@range.begin, @range.end]
265
- in nil, nil
283
+ in [nil, nil]
266
284
  size.times.map { SIMPLE_SOURCE.sample }.join
267
- in nil, _
268
- raise "Should set range.begin and range.end"
269
- in _, nil
285
+ in [nil, _] | [_, nil]
270
286
  raise "Should set range.begin and range.end"
271
- in s, e
287
+ in [s, e]
272
288
  a = (s..e).to_a
273
289
  size.times.map { a.sample }.join
274
290
  end
@@ -278,14 +294,28 @@ module RaaP
278
294
 
279
295
  def symbol
280
296
  sized do |size|
281
- string.pick(size: size).to_sym
297
+ string.pick(size:).to_sym
282
298
  end
283
299
  end
284
300
 
285
301
  def array(type)
286
302
  sized do |size|
287
- Array.new(integer.pick(size: size).abs) do
288
- type.pick(size: size)
303
+ Array.new(integer.pick(size:).abs) do
304
+ type.to_symbolic_call(size: size / 2)
305
+ end
306
+ end
307
+ end
308
+
309
+ # Create Hash object. But not `hash`.
310
+ # Avoid to use `hash` since core method name
311
+ def dict(key_type, value_type)
312
+ sized do |size|
313
+ csize = size / 2
314
+ Array.new(integer.pick(size:).abs).to_h do
315
+ [
316
+ key_type.to_symbolic_call(size: csize),
317
+ value_type.to_symbolic_call(size: csize)
318
+ ]
289
319
  end
290
320
  end
291
321
  end
@@ -293,7 +323,7 @@ module RaaP
293
323
  def encoding
294
324
  sized do
295
325
  e = Encoding.list.sample or raise
296
- [:call, Encoding, :find, [e.name], {} , nil]
326
+ [:call, Encoding, :find, [e.name], {}, nil]
297
327
  end
298
328
  end
299
329
 
@@ -303,24 +333,10 @@ module RaaP
303
333
  end
304
334
  end
305
335
 
306
- def untyped
307
- case Random.rand(9)
308
- in 0 then integer
309
- in 1 then float
310
- in 2 then rational
311
- in 3 then complex
312
- in 4 then string
313
- in 5 then symbol
314
- in 6 then bool
315
- in 7 then encoding
316
- in 8 then sized { BasicObject.new }
317
- end
318
- end
319
-
320
336
  def temp_method_object
321
337
  o = Object.new
322
338
  m = 6.times.map { SIMPLE_SOURCE.sample }.join
323
- o.define_singleton_method(m) { }
339
+ o.define_singleton_method(m) {}
324
340
  o.method(m)
325
341
  end
326
342
  end
@@ -14,7 +14,7 @@ module RaaP
14
14
  elsif bound.upper_bound
15
15
  [bound.name, bound.upper_bound]
16
16
  else
17
- [bound.name, ::RBS::Types::Bases::Top.new(location: nil)]
17
+ [bound.name, ::RBS::Types::Variable.new(name: bound.name, location: nil)]
18
18
  end
19
19
  end
20
20
  ::RBS::Substitution.build(bound_map.keys, bound_map.values)
@@ -36,6 +36,7 @@ module RaaP
36
36
  if self_type.nil? && instance_type.nil? && class_type.nil?
37
37
  return search
38
38
  end
39
+
39
40
  search.map_type do |ty|
40
41
  case ty
41
42
  when ::RBS::Types::Bases::Self
@@ -5,22 +5,26 @@ module RaaP
5
5
  class Interface < BasicObject
6
6
  def initialize(type, size: 3, self_type: nil, instance_type: nil, class_type: nil)
7
7
  @type = type.is_a?(::String) ? RBS.parse_type(type) : type
8
+ unless @type.instance_of?(::RBS::Types::Interface)
9
+ ::Kernel.raise ::TypeError, "not an interface type: #{@type}"
10
+ end
8
11
  @size = size
9
12
 
10
- definition = RBS.builder.build_interface(@type.name.absolute!)
11
- definition.methods.each do |name, method|
13
+ @definition = RBS.builder.build_interface(@type.name.absolute!)
14
+ @definition.methods.each do |name, method|
12
15
  method_type = method.method_types.sample or Kernel.raise
13
- type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
16
+ type_params = @definition.type_params_decl.concat(method_type.type_params.drop(@definition.type_params_decl.length))
14
17
  ts = TypeSubstitution.new(type_params, @type.args)
15
18
 
16
19
  subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
17
20
 
18
- BindCall.define_singleton_method(self, name) do |*, &b|
19
- @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size: size)
21
+ BindCall.define_singleton_method(self, name) do |*_, &b|
22
+ # @type var b: Proc?
23
+ @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size:)
20
24
  if subed_method_type.block
21
25
  @fixed_block_arguments ||= size.times.map do
22
26
  fun_type = FunctionType.new(subed_method_type.block.type)
23
- fun_type.pick_arguments(size: size)
27
+ fun_type.pick_arguments(size:)
24
28
  end
25
29
  else
26
30
  @fixed_block_arguments = []
@@ -38,12 +42,16 @@ module RaaP
38
42
  end
39
43
  end
40
44
 
45
+ def respond_to?(name, _include_all = false)
46
+ @definition.methods.has_key?(name.to_sym)
47
+ end
48
+
41
49
  def class
42
50
  Interface
43
51
  end
44
52
 
45
53
  def inspect
46
- "#<interface @type=#{@type.to_s} @methods=#{RBS.builder.build_interface(@type.name.absolute!).methods.keys} @size=#{@size}>"
54
+ "#<interface @type=#{@type} @methods=#{@definition.methods.keys} @size=#{@size}>"
47
55
  end
48
56
  end
49
57
  end
@@ -3,14 +3,17 @@
3
3
  module RaaP
4
4
  module Value
5
5
  class Intersection < BasicObject
6
- def initialize(type, size:)
7
- @type = type
8
- @children = type.types.map { |t| Type.new(t).pick(size: size) }
6
+ def initialize(type, size: 3)
7
+ @type = type.is_a?(::String) ? RBS.parse_type(type) : type
8
+ unless @type.instance_of?(::RBS::Types::Intersection)
9
+ ::Kernel.raise ::TypeError, "not an intersection type: #{@type}"
10
+ end
11
+ @children = @type.types.map { |t| Type.new(t).pick(size:) }
9
12
  @size = size
10
13
  end
11
14
 
12
15
  def inspect
13
- "#<intersection @type=#{@type.to_s.inspect} @size=#{@size.inspect}>"
16
+ "#<intersection @type.to_s=#{@type.to_s.inspect} @size=#{@size.inspect}>"
14
17
  end
15
18
 
16
19
  def class
@@ -18,16 +21,25 @@ module RaaP
18
21
  end
19
22
 
20
23
  def method_missing(name, *args, **kwargs, &block)
21
- @children.each do |child|
22
- if BindCall.respond_to?(child, name)
23
- return child.__send__(name, *args, **kwargs, &block)
24
+ if respond_to?(name)
25
+ @children.each do |child|
26
+ if BindCall.respond_to?(child, name)
27
+ return child.__send__(name, *args, **kwargs, &block)
28
+ end
24
29
  end
30
+ ::Kernel.raise
31
+ else
32
+ super
25
33
  end
26
34
  end
27
35
 
28
- def respond_to?(...)
29
- @children.any? do |type|
30
- BindCall.respond_to?(type, ...)
36
+ def respond_to?(name, include_all = false)
37
+ @children.any? do |child|
38
+ if BindCall.instance_of?(child, ::BasicObject)
39
+ BindCall.respond_to?(child, name, include_all)
40
+ else
41
+ child.respond_to?(name, include_all)
42
+ end
31
43
  end
32
44
  end
33
45
  end
@@ -1,16 +1,56 @@
1
1
  module RaaP
2
2
  module Value
3
3
  # FIXME: consider self_types
4
+ # HINT: intersection?
4
5
  class Module < BasicObject
5
- attr_reader :type
6
+ def initialize(type, size: 3)
7
+ @type = type.is_a?(::String) ? ::RaaP::RBS.parse_type(type) : type
8
+ @size = size
9
+ unless @type.instance_of?(::RBS::Types::ClassInstance)
10
+ ::Kernel.raise ::TypeError, "not a module type: #{@type}"
11
+ end
6
12
 
7
- def initialize(type)
8
- @type = type
9
- const = ::Object.const_get(type.name.absolute!.to_s)
10
- BindCall.extend(self, const)
13
+ one_instance_ancestors = ::RaaP::RBS.builder.ancestor_builder.one_instance_ancestors(@type.name.absolute!).self_types
14
+ @self_type = if one_instance_ancestors.nil? || one_instance_ancestors.empty?
15
+ ::Object.new
16
+ else
17
+ one_instance_ancestors.map do |a_instance|
18
+ if a_instance.args.empty?
19
+ # : BasicObject
20
+ a_instance.name.absolute!.to_s
21
+ else
22
+ # : _Each[Integer]
23
+ args = a_instance.args.zip(@type.args).map do |_var, instance|
24
+ if instance
25
+ instance.to_s
26
+ else
27
+ 'untyped'
28
+ end
29
+ end
30
+ "#{a_instance.name}[#{args.map(&:to_s).join(', ')}]"
31
+ end
32
+ end.then do |ts|
33
+ ts << 'Object' if !ts.include?('::BasicObject')
34
+ Type.new(ts.join(' & ')).pick(size:)
35
+ end
36
+ end
37
+ const = ::Object.const_get(@type.name.absolute!.to_s)
38
+ BindCall.extend(@self_type, const)
11
39
  end
12
40
 
13
- def inspect = "#<module #{@type}>"
41
+ def method_missing(name, *args, **kwargs, &block)
42
+ @self_type.__send__(name, *args, **kwargs, &block)
43
+ end
44
+
45
+ def respond_to?(name, include_all = false)
46
+ if BindCall.instance_of?(@self_type, ::BasicObject)
47
+ BindCall.respond_to?(@self_type, name, include_all)
48
+ else
49
+ @self_type.respond_to?(name, include_all)
50
+ end
51
+ end
52
+
53
+ def inspect = "#<module #{@type} : #{BindCall.class(@self_type)} size=#{@size}>"
14
54
  def class = Value::Module
15
55
  end
16
56
  end
@@ -4,7 +4,16 @@ module RaaP
4
4
  attr_reader :type
5
5
 
6
6
  def initialize(type)
7
- @type = type
7
+ @type =
8
+ if type.respond_to?(:to_sym)
9
+ # @type var type: String | Symbol
10
+ ::RBS::Types::Variable.new(name: type.to_sym, location: nil)
11
+ else
12
+ type
13
+ end
14
+ unless @type.instance_of?(::RBS::Types::Variable)
15
+ ::Kernel.raise ::TypeError, "not a variable type: #{@type}"
16
+ end
8
17
  end
9
18
 
10
19
  def inspect = "#<var #{type}>"
data/lib/raap/version.rb CHANGED
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module RaaP
4
- VERSION = "0.2.0"
4
+ VERSION = "0.4.0"
5
5
  end
data/lib/raap.rb CHANGED
@@ -15,7 +15,9 @@ module RaaP
15
15
  attr_accessor :logger
16
16
  end
17
17
 
18
- self.logger = ::Logger.new($stdout)
18
+ self.logger = ::Logger.new($stdout, formatter: proc { |severity, _datetime, _progname, msg|
19
+ "[RaaP] #{severity}: #{msg}\n"
20
+ })
19
21
  self.logger.level = ::Logger::INFO
20
22
 
21
23
  autoload :BindCall, "raap/bind_call"
@@ -23,8 +25,6 @@ module RaaP
23
25
  autoload :FunctionType, "raap/function_type"
24
26
  autoload :MethodProperty, "raap/method_property"
25
27
  autoload :MethodType, "raap/method_type"
26
- autoload :MethodValue, "raap/method_value"
27
- autoload :Minitest, "raap/minitest"
28
28
  autoload :RBS, "raap/rbs"
29
29
  autoload :Result, "raap/result"
30
30
  autoload :Sized, "raap/sized"
Binary file
@@ -5,10 +5,58 @@ gems:
5
5
  version: '0'
6
6
  source:
7
7
  type: stdlib
8
+ - name: activesupport
9
+ version: '7.0'
10
+ source:
11
+ type: git
12
+ name: ruby/gem_rbs_collection
13
+ revision: bc4cbee282cfb013be8c44a3fe7a374491492400
14
+ remote: https://github.com/ruby/gem_rbs_collection.git
15
+ repo_dir: gems
16
+ - name: base64
17
+ version: '0'
18
+ source:
19
+ type: stdlib
20
+ - name: bigdecimal
21
+ version: '0'
22
+ source:
23
+ type: stdlib
24
+ - name: concurrent-ruby
25
+ version: '1.1'
26
+ source:
27
+ type: git
28
+ name: ruby/gem_rbs_collection
29
+ revision: bc4cbee282cfb013be8c44a3fe7a374491492400
30
+ remote: https://github.com/ruby/gem_rbs_collection.git
31
+ repo_dir: gems
32
+ - name: connection_pool
33
+ version: '2.4'
34
+ source:
35
+ type: git
36
+ name: ruby/gem_rbs_collection
37
+ revision: bc4cbee282cfb013be8c44a3fe7a374491492400
38
+ remote: https://github.com/ruby/gem_rbs_collection.git
39
+ repo_dir: gems
40
+ - name: date
41
+ version: '0'
42
+ source:
43
+ type: stdlib
44
+ - name: erb
45
+ version: '0'
46
+ source:
47
+ type: stdlib
8
48
  - name: fileutils
9
49
  version: '0'
10
50
  source:
11
51
  type: stdlib
52
+ - name: i18n
53
+ version: '1.10'
54
+ source:
55
+ type: git
56
+ name: ruby/gem_rbs_collection
57
+ revision: bc4cbee282cfb013be8c44a3fe7a374491492400
58
+ remote: https://github.com/ruby/gem_rbs_collection.git
59
+ repo_dir: gems
12
60
  - name: io-console
13
61
  version: '0'
14
62
  source:
@@ -46,7 +94,7 @@ gems:
46
94
  source:
47
95
  type: git
48
96
  name: ruby/gem_rbs_collection
49
- revision: be76a75932e8ed6ee91a95ba936cf88b674bf044
97
+ revision: bc4cbee282cfb013be8c44a3fe7a374491492400
50
98
  remote: https://github.com/ruby/gem_rbs_collection.git
51
99
  repo_dir: gems
52
100
  - name: rbs
@@ -57,6 +105,18 @@ gems:
57
105
  version: '0'
58
106
  source:
59
107
  type: stdlib
108
+ - name: securerandom
109
+ version: '0'
110
+ source:
111
+ type: stdlib
112
+ - name: singleton
113
+ version: '0'
114
+ source:
115
+ type: stdlib
116
+ - name: time
117
+ version: '0'
118
+ source:
119
+ type: stdlib
60
120
  - name: timeout
61
121
  version: '0'
62
122
  source:
data/rbs_collection.yaml CHANGED
@@ -15,6 +15,5 @@ path: .gem_rbs_collection
15
15
 
16
16
  gems:
17
17
  - name: activesupport
18
- ignore: true
19
18
  - name: steep
20
19
  ignore: true