Runtime assertions for Ruby literal.fun
ruby
5
fork

Configure Feed

Select the types of activity you want to include in your feed.

Use positional arguments for Literal.check

+37 -55
+1 -1
lib/literal.rb
··· 77 77 Literal::Brand.new(...) 78 78 end 79 79 80 - def self.check(actual:, expected:) 80 + def self.check(actual, expected) 81 81 if expected === actual 82 82 true 83 83 else
+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
··· 10 10 end 11 11 12 12 def initialize(value) 13 - Literal.check(expected: __type__, actual: value) 13 + Literal.check(value, __type__) 14 14 super 15 15 freeze 16 16 end
+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
··· 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
··· 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
··· 26 26 def initialize(value, type:) 27 27 collection_type = Literal::Types::SetType.new(type) 28 28 29 - Literal.check(actual: value, expected: collection_type) do |c| 29 + Literal.check(value, collection_type) do |c| 30 30 c.fill_receiver(receiver: self, method: "#initialize") 31 31 end 32 32
+1 -1
lib/literal/value.rb
··· 23 23 end 24 24 25 25 def initialize(value) 26 - Literal.check(expected: __type__, actual: value) 26 + Literal.check(value, __type__) 27 27 @value = value 28 28 freeze 29 29 end
+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
··· 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
··· 27 27 28 28 test "error message" do 29 29 error = assert_raises Literal::TypeError do 30 - Literal.check( 31 - expected: _Interface(:each, :map, :select), actual: nil 32 - ) 30 + Literal.check(nil, _Interface(:each, :map, :select)) 33 31 end 34 32 35 33 assert_equal error.message, <<~MSG
+2 -2
test/types/_intersection.test.rb
··· 24 24 test "error message" do 25 25 error = assert_raises(Literal::TypeError) do 26 26 Literal.check( 27 - actual: "string", 28 - expected: _Intersection( 27 + "string", 28 + _Intersection( 29 29 _Interface(:size), 30 30 _Interface(:each), 31 31 )
+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
··· 24 24 test "error message" do 25 25 error = assert_raises Literal::TypeError do 26 26 Literal.check( 27 - expected: _Map(name: String, age: Integer), 28 - actual: { name: "Alice", age: "42" } 27 + { name: "Alice", age: "42" }, 28 + _Map(name: String, age: Integer), 29 29 ) 30 30 end 31 31
+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
··· 25 25 26 26 test "error message" do 27 27 error = assert_raises Literal::TypeError do 28 - Literal.check( 29 - expected: _Not(Integer), 30 - actual: 18 31 - ) 28 + Literal.check(18, _Not(Integer)) 32 29 end 33 30 34 31 assert_equal error.message, <<~MSG
+1 -1
test/types/_range.test.rb
··· 21 21 22 22 test "type error" do 23 23 message = assert_raises(Literal::TypeError) do 24 - Literal.check(actual: (1.0..10.0), expected: _Range(Integer)) 24 + Literal.check((1.0..10.0), _Range(Integer)) 25 25 end 26 26 27 27 assert_equal message.message, <<~MSG
+1 -1
test/types/_set.test.rb
··· 21 21 22 22 test "error message" do 23 23 error = assert_raises(Literal::TypeError) do 24 - Literal.check(expected: _Set(String), actual: Set["1", 2, "3", nil]) 24 + Literal.check(Set["1", 2, "3", nil], _Set(String)) 25 25 end 26 26 27 27 assert_equal error.message, <<~MSG
+2 -2
test/types/_tuple.test.rb
··· 21 21 test "error message" do 22 22 error = assert_raises(Literal::TypeError) do 23 23 Literal.check( 24 - expected: _Tuple(String, Integer), 25 - actual: [1, "a"] 24 + [1, "a"], 25 + _Tuple(String, Integer), 26 26 ) 27 27 end 28 28
+1 -4
test/types/_union.test.rb
··· 87 87 88 88 test "error message" do 89 89 error = assert_raises Literal::TypeError do 90 - Literal.check( 91 - expected: _Union(String, Integer), 92 - actual: :symbol 93 - ) 90 + Literal.check(:symbol, _Union(String, Integer)) 94 91 end 95 92 96 93 assert_equal error.message, <<~ERROR