Module: DataModel::Errors

Extended by:
Errors, T::Sig
Includes:
Kernel
Included in:
Builtin::Array, Builtin::BigDecimal, Builtin::Boolean, Builtin::Date, Builtin::Float, Builtin::Hash, Builtin::Integer, Builtin::String, Builtin::Symbol, Builtin::Time, Error, Errors
Defined in:
lib/data_model/errors.rb

Overview

Provide Error building functionality as a mixin

Constant Summary collapse

TTemporal = 
T.type_alias { T.any(::Date, ::Time, ::DateTime) }
TErrorMessageBuilder =

Builders

T.type_alias { T.proc.params(ctx: T.untyped).returns(String) }
TErrorMessages = 
T.type_alias { T::Hash[Symbol, TErrorMessageBuilder] }
TClassValueCtx = 
T.type_alias { [T.class_of(Object), Object] }
TClassCtx = 
T.type_alias { T.class_of(Object) }
TSetCtx = 
T.type_alias { T::Array[Symbol] }
TWithinCtx = 
T.type_alias { [Numeric, Numeric] }
TWithinTemporalCtx = 
T.type_alias { [Errors::TTemporal, Errors::TTemporal] }
TFormatCtx = 
T.type_alias { [Object, String] }

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.error_messages ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/data_model/errors.rb', line 173

def self.error_messages
  return {
    type: lambda do |ctx|
      cls, val = T.let(ctx, TClassValueCtx)
      type_error_message(cls, val)
    end,

    coerce: lambda do |ctx|
      cls, val = T.let(ctx, TClassValueCtx)
      type_error_message(cls, val)
    end,

    missing: lambda do |ctx|
      cls = T.let(ctx, TClassCtx)
      missing_error_message(cls)
    end,

    inclusion: lambda do |ctx|
      set = T.let(ctx, TSetCtx)
      inclusion_error_message(set)
    end,

    exclusion: lambda do |ctx|
      set = T.let(ctx, TSetCtx)
      exclusion_error_message(set)
    end,

    extra_keys: lambda do |ctx|
      set = T.let(ctx, TSetCtx)
      extra_keys_error_message(set)
    end,

    min: lambda do |ctx|
      min, val = T.let(ctx, TWithinCtx)
      min_error_message(min, val)
    end,

    max: lambda do |ctx|
      max, val = T.let(ctx, TWithinCtx)
      max_error_message(max, val)
    end,

    earliest: lambda do |ctx|
      earliest, val = T.let(ctx, TWithinTemporalCtx)
      early_error_message(earliest, val)
    end,

    latest: lambda do |ctx|
      latest, val = T.let(ctx, TWithinTemporalCtx)
      late_error_message(latest, val)
    end,

    blank: lambda do
      blank_error_message
    end,

    format: lambda do |ctx|
      format, val = T.let(ctx, TFormatCtx)
      format_error_message(format, val)
    end
  }
end

Instance Method Details

#blank_error ⇒ Object 



46
47
48
 
# File 'lib/data_model/errors.rb', line 46

def blank_error
  [:blank, nil]
end

#blank_error_message ⇒ Object 



120
121
122
 
# File 'lib/data_model/errors.rb', line 120

def blank_error_message
  "cannot be blank"
end

#coerce_error(cls, value) ⇒ Object 



22
23
24
 
# File 'lib/data_model/errors.rb', line 22

def coerce_error(cls, value)
  [:coerce, [cls, value]]
end

#coerce_error_message(cls, value) ⇒ Object 



96
97
98
 
# File 'lib/data_model/errors.rb', line 96

def coerce_error_message(cls, value)
  "cannot be coerced to #{cls.name}, it is a #{value.class.name}"
end

#earliest_error(earliest, val) ⇒ Object 



70
71
72
 
# File 'lib/data_model/errors.rb', line 70

def earliest_error(earliest, val)
  [:earliest, [earliest, val]]
end

#early_error_message(earliest, val) ⇒ Object 



144
145
146
 
# File 'lib/data_model/errors.rb', line 144

def early_error_message(earliest, val)
  "value #{val} is before #{earliest}"
end

#exclusion_error(set) ⇒ Object 



40
41
42
 
# File 'lib/data_model/errors.rb', line 40

def exclusion_error(set)
  [:exclusion, set]
end

#exclusion_error_message(set) ⇒ Object 



114
115
116
 
# File 'lib/data_model/errors.rb', line 114

def exclusion_error_message(set)
  "must not be one of #{set.join(', ')}"
end

#extra_keys_error(keys) ⇒ Object 



52
53
54
 
# File 'lib/data_model/errors.rb', line 52

def extra_keys_error(keys)
  [:extra_keys, keys]
end

#extra_keys_error_message(keys) ⇒ Object 



126
127
128
 
# File 'lib/data_model/errors.rb', line 126

def extra_keys_error_message(keys)
  "more elements found in closed hash then specified children: #{keys.join(', ')}"
end

#format_error(format, val) ⇒ Object 



82
83
84
 
# File 'lib/data_model/errors.rb', line 82

def format_error(format, val)
  [:format, [format, val]]
end

#format_error_message(format, val) ⇒ Object 



156
157
158
 
# File 'lib/data_model/errors.rb', line 156

def format_error_message(format, val)
  "value #{val} does not match format #{format}"
end

#inclusion_error(set) ⇒ Object 



34
35
36
 
# File 'lib/data_model/errors.rb', line 34

def inclusion_error(set)
  [:inclusion, set]
end

#inclusion_error_message(set) ⇒ Object 



108
109
110
 
# File 'lib/data_model/errors.rb', line 108

def inclusion_error_message(set)
  "must be one of #{set.join(', ')}"
end

#late_error_message(latest, val) ⇒ Object 



150
151
152
 
# File 'lib/data_model/errors.rb', line 150

def late_error_message(latest, val)
  "value #{val} is after #{latest}"
end

#latest_error(latest, val) ⇒ Object 



76
77
78
 
# File 'lib/data_model/errors.rb', line 76

def latest_error(latest, val)
  [:latest, [latest, val]]
end

#max_error(min, val) ⇒ Object 



64
65
66
 
# File 'lib/data_model/errors.rb', line 64

def max_error(min, val)
  [:max, [min, val]]
end

#max_error_message(max, val) ⇒ Object 



138
139
140
 
# File 'lib/data_model/errors.rb', line 138

def max_error_message(max, val)
  "value is more than the maximum of #{max}, it is #{val}"
end

#min_error(min, val) ⇒ Object 



58
59
60
 
# File 'lib/data_model/errors.rb', line 58

def min_error(min, val)
  [:min, [min, val]]
end

#min_error_message(min, val) ⇒ Object 



132
133
134
 
# File 'lib/data_model/errors.rb', line 132

def min_error_message(min, val)
  "value is less than the minimum of #{min}, it is #{val}"
end

#missing_error(cls) ⇒ Object 



28
29
30
 
# File 'lib/data_model/errors.rb', line 28

def missing_error(cls)
  [:missing, cls]
end

#missing_error_message(cls) ⇒ Object 



102
103
104
 
# File 'lib/data_model/errors.rb', line 102

def missing_error_message(cls)
  "missing value, expected a #{cls.name}"
end

#type_error(cls, value) ⇒ Object 



16
17
18
 
# File 'lib/data_model/errors.rb', line 16

def type_error(cls, value)
  [:type, [cls, value]]
end

#type_error_message(cls, value) ⇒ Object 



90
91
92
 
# File 'lib/data_model/errors.rb', line 90

def type_error_message(cls, value)
  "#{value.inspect} is not a #{cls.name}, it is a #{value.class.name}"
end