Runtime assertions for Ruby
literal.fun
ruby
Use positional arguments for Literal.check
+37
-55
+1
-1
lib/literal.rb
+1
-1
lib/literal.rb
+10
-10
lib/literal/array.rb
+10
-10
lib/literal/array.rb
···
51
51
include Literal::Types
52
52
53
53
def initialize(value, type:)
54
-
Literal.check(actual: value, expected: _Array(type)) do |c|
54
+
Literal.check(value, _Array(type)) do |c|
55
55
c.fill_receiver(receiver: self, method: "#initialize")
56
56
end
57
57
···
98
98
def +(other)
99
99
case other
100
100
when ::Array
101
-
Literal.check(actual: other, expected: _Array(@__type__)) do |c|
101
+
Literal.check(other, _Array(@__type__)) do |c|
102
102
c.fill_receiver(receiver: self, method: "#+")
103
103
end
104
104
···
129
129
end
130
130
131
131
def <<(value)
132
-
Literal.check(actual: value, expected: @__type__) do |c|
132
+
Literal.check(value, @__type__) do |c|
133
133
c.fill_receiver(receiver: self, method: "#<<")
134
134
end
135
135
···
157
157
end
158
158
159
159
def []=(index, value)
160
-
Literal.check(actual: value, expected: @__type__) do |c|
160
+
Literal.check(value, @__type__) do |c|
161
161
c.fill_receiver(receiver: self, method: "#[]=")
162
162
end
163
163
···
284
284
alias_method :index, :find_index
285
285
286
286
def insert(index, *value)
287
-
Literal.check(actual: value, expected: _Array(@__type__)) do |c|
287
+
Literal.check(value, _Array(@__type__)) do |c|
288
288
c.fill_receiver(receiver: self, method: "#insert")
289
289
end
290
290
···
398
398
399
399
if __type__ != type
400
400
@__value__.each do |item|
401
-
Literal.check(actual: item, expected: type) do |c|
401
+
Literal.check(item, type) do |c|
402
402
c.fill_receiver(receiver: self, method: "#narrow")
403
403
end
404
404
end
···
453
453
end
454
454
455
455
def push(*value)
456
-
Literal.check(actual: value, expected: _Array(@__type__)) do |c|
456
+
Literal.check(value, _Array(@__type__)) do |c|
457
457
c.fill_receiver(receiver: self, method: "#push")
458
458
end
459
459
···
475
475
def replace(value)
476
476
case value
477
477
when Array
478
-
Literal.check(actual: value, expected: _Array(@__type__)) do |c|
478
+
Literal.check(value, _Array(@__type__)) do |c|
479
479
c.fill_receiver(receiver: self, method: "#replace")
480
480
end
481
481
···
597
597
end
598
598
599
599
def unshift(value)
600
-
Literal.check(actual: value, expected: @__type__) do |c|
600
+
Literal.check(value, @__type__) do |c|
601
601
c.fill_receiver(receiver: self, method: "#unshift")
602
602
end
603
603
···
636
636
def |(other)
637
637
case other
638
638
when ::Array
639
-
Literal.check(actual: other, expected: _Array(@__type__)) do |c|
639
+
Literal.check(other, _Array(@__type__)) do |c|
640
640
c.fill_receiver(receiver: self, method: "#|")
641
641
end
642
642
+1
-1
lib/literal/delegator.rb
+1
-1
lib/literal/delegator.rb
+2
-2
lib/literal/enum.rb
+2
-2
lib/literal/enum.rb
···
55
55
56
56
types = @indexes_definitions.fetch(key)
57
57
type = types.first
58
-
Literal.check(actual: value, expected: type) { |c| raise NotImplementedError }
58
+
Literal.check(value, type) { |c| raise NotImplementedError }
59
59
60
60
@indexes.fetch(key)[value]
61
61
end
···
72
72
end
73
73
74
74
type = @indexes_definitions.fetch(key)[0]
75
-
Literal.check(actual: value, expected: type)
75
+
Literal.check(value, type)
76
76
77
77
@indexes.fetch(key)[value]&.first
78
78
end
+1
-1
lib/literal/hash.rb
+1
-1
lib/literal/hash.rb
···
25
25
def initialize(value, key_type:, value_type:)
26
26
collection_type = Literal::Types::HashType.new(key_type, value_type)
27
27
28
-
Literal.check(actual: value, expected: collection_type) do |c|
28
+
Literal.check(value, collection_type) do |c|
29
29
c.fill_receiver(receiver: self, method: "#initialize")
30
30
end
31
31
+3
-3
lib/literal/property.rb
+3
-3
lib/literal/property.rb
···
97
97
def check(value, &)
98
98
raise ArgumentError.new("Cannot check type without a block") unless block_given?
99
99
100
-
Literal.check(actual: value, expected: @type, &)
100
+
Literal.check(value, @type, &)
101
101
end
102
102
103
103
def check_writer(receiver, value)
104
-
Literal.check(actual: value, expected: @type) { |c| c.fill_receiver(receiver:, method: "##{@name.name}=(value)") }
104
+
Literal.check(value, @type) { |c| c.fill_receiver(receiver:, method: "##{@name.name}=(value)") }
105
105
end
106
106
107
107
def check_initializer(receiver, value)
108
-
Literal.check(actual: value, expected: @type) { |c| c.fill_receiver(receiver:, method: "#initialize", label: param) }
108
+
Literal.check(value, @type) { |c| c.fill_receiver(receiver:, method: "#initialize", label: param) }
109
109
end
110
110
111
111
def generate_reader_method(buffer = +"")
+1
-1
lib/literal/set.rb
+1
-1
lib/literal/set.rb
+1
-1
lib/literal/value.rb
+1
-1
lib/literal/value.rb
+1
-4
test/types/_constraint.test.rb
+1
-4
test/types/_constraint.test.rb
···
25
25
26
26
test "error message with object constraints" do
27
27
error = assert_raises Literal::TypeError do
28
-
Literal.check(
29
-
expected: _Constraint(Integer, 18..),
30
-
actual: 17
31
-
)
28
+
Literal.check(17, _Constraint(Integer, 18..))
32
29
end
33
30
34
31
assert_equal error.message, <<~MSG
+2
-6
test/types/_hash.test.rb
+2
-6
test/types/_hash.test.rb
···
21
21
22
22
test "key error" do
23
23
error = assert_raises Literal::TypeError do
24
-
Literal.check(
25
-
expected: _Hash(Symbol, Integer), actual: { 1 => 2, :a => :b, :d => 2 }
26
-
)
24
+
Literal.check({ 1 => 2, :a => :b, :d => 2 }, _Hash(Symbol, Integer))
27
25
end
28
26
29
27
assert_equal error.message, <<~MSG
···
40
38
41
39
test "top level error" do
42
40
error = assert_raises Literal::TypeError do
43
-
Literal.check(
44
-
expected: _Hash(Symbol, Integer), actual: nil
45
-
)
41
+
Literal.check(nil, _Hash(Symbol, Integer))
46
42
end
47
43
48
44
assert_equal error.message, <<~MSG
+1
-3
test/types/_interface.test.rb
+1
-3
test/types/_interface.test.rb
+2
-2
test/types/_intersection.test.rb
+2
-2
test/types/_intersection.test.rb
+2
-2
test/types/_json_data.test.rb
+2
-2
test/types/_json_data.test.rb
···
75
75
test "error message" do
76
76
error = assert_raises(Literal::TypeError) do
77
77
Literal.check(
78
-
actual: { :key => "value", "string" => "string", "symbol" => :symbol, "array" => [1, 2, 3, :symbol], "hash" => { "key" => "value", "symbol" => :symbol } },
79
-
expected: _JSONData
78
+
{ :key => "value", "string" => "string", "symbol" => :symbol, "array" => [1, 2, 3, :symbol], "hash" => { "key" => "value", "symbol" => :symbol } },
79
+
_JSONData
80
80
)
81
81
end
82
82
+2
-2
test/types/_map.test.rb
+2
-2
test/types/_map.test.rb
+1
-4
test/types/_nilable.test.rb
+1
-4
test/types/_nilable.test.rb
···
25
25
26
26
test "error message" do
27
27
error = assert_raises Literal::TypeError do
28
-
Literal.check(
29
-
expected: _Nilable(_Hash(Symbol, Integer)),
30
-
actual: { 1 => 2, :a => :b, :d => 2 }
31
-
)
28
+
Literal.check({ 1 => 2, :a => :b, :d => 2 }, _Nilable(_Hash(Symbol, Integer)))
32
29
end
33
30
34
31
assert_equal error.message, <<~MSG
+1
-4
test/types/_not.test.rb
+1
-4
test/types/_not.test.rb
+1
-1
test/types/_range.test.rb
+1
-1
test/types/_range.test.rb
+1
-1
test/types/_set.test.rb
+1
-1
test/types/_set.test.rb
+2
-2
test/types/_tuple.test.rb
+2
-2
test/types/_tuple.test.rb
+1
-4
test/types/_union.test.rb
+1
-4
test/types/_union.test.rb