1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
# frozen_string_literal: true
module Dry
module Types
extend ::Dry::Core::ClassAttributes
# @!attribute [r] namespace
# @return [Container{String => Nominal}]
defines :namespace
namespace self
# Base class for coercion errors raise by dry-types
#
class CoercionError < ::StandardError
# @api private
def self.handle(exception, meta: Undefined)
if block_given?
yield
else
raise new(
exception.message,
meta: meta,
backtrace: exception.backtrace
)
end
end
# Metadata associated with the error
#
# @return [Object]
attr_reader :meta
# @api private
def initialize(message, meta: Undefined, backtrace: Undefined)
unless message.is_a?(::String)
raise ::ArgumentError, "message must be a string, #{message.class} given"
end
super(message)
@meta = Undefined.default(meta, nil)
set_backtrace(backtrace) unless Undefined.equal?(backtrace)
end
end
# Collection of multiple errors
#
class MultipleError < CoercionError
# @return [Array<CoercionError>]
attr_reader :errors
# @param [Array<CoercionError>] errors
def initialize(errors)
@errors = errors
end
# @return string
def message
errors.map(&:message).join(', ')
end
# @return [Array]
def meta
errors.map(&:meta)
end
end
class SchemaError < CoercionError
# @param [String,Symbol] key
# @param [Object] value
# @param [String, #to_s] result
def initialize(key, value, result)
super("#{value.inspect} (#{value.class}) has invalid type for :#{key} violates constraints (#{result} failed)")
end
end
MapError = ::Class.new(CoercionError)
SchemaKeyError = ::Class.new(CoercionError)
private_constant(:SchemaKeyError)
class MissingKeyError < SchemaKeyError
# @return [Symbol]
attr_reader :key
# @param [String,Symbol] key
def initialize(key)
@key = key
super("#{key.inspect} is missing in Hash input")
end
end
class UnknownKeysError < SchemaKeyError
# @return [Array<Symbol>]
attr_reader :keys
# @param [<String, Symbol>] keys
def initialize(keys)
@keys = keys
super("unexpected keys #{keys.inspect} in Hash input")
end
end
class ConstraintError < CoercionError
# @return [String, #to_s]
attr_reader :result
# @return [Object]
attr_reader :input
# @param [String, #to_s] result
# @param [Object] input
def initialize(result, input)
@result = result
@input = input
if result.is_a?(String)
super(result)
else
super(to_s)
end
end
# @return [String]
def message
"#{input.inspect} violates constraints (#{result} failed)"
end
alias_method :to_s, :message
end
end
end
|
