Module: Foobara::CommandPatternImplementation::Concerns::ErrorsType::ClassMethods

Defined in:
foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb

Instance Method Summary collapse

Instance Method Details

#error_context_type_map ⇒ Object

TODO: kill this method in favor of possible_errors



95
96
97
98
99
100
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 95

def error_context_type_map
  process_error_constants
  @error_context_type_map ||= if superclass < Foobara::Command
                                superclass.error_context_type_map.dup
                              end || {}
end

#manually_added_possible_input_errors ⇒ Object 



90
91
92
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 90

def manually_added_possible_input_errors
  @manually_added_possible_input_errors ||= []
end

#possible_error(*args) ⇒ Object 



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
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 26

def possible_error(*args)
  possible_error = case args.size
                   when 1
                     arg = args.first

                     if arg.is_a?(PossibleError)
                       # TODO: test this code path
                       # :nocov:
                       arg
                       # :nocov:
                     elsif arg.is_a?(::Class) && arg < Foobara::Error
                       PossibleError.new(arg)
                     elsif arg.is_a?(::Symbol)
                       error_class = Foobara::RuntimeError.subclass(mod: self, symbol: arg)
                       PossibleError.new(error_class, symbol: arg)
                     else
                       # :nocov:
                       raise ArgumentError, "Expected a PossibleError or an Error but got #{arg}"
                       # :nocov:
                     end
                   when 2
                     symbol, subclass_parameters, data = args

                     error_class = Foobara::RuntimeError.subclass(
                       mod: self,
                       **subclass_parameters,
                       symbol:
                     )

                     PossibleError.new(error_class, symbol:, data:)
                   else
                     # :nocov:
                     raise ArgumentError, "Expected an error or a symbol and error context type declaration"
                     # :nocov:
                   end

  register_possible_error_class(possible_error)
end

#possible_errors ⇒ Object 



22
23
24
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 22

def possible_errors
  error_context_type_map.values
end

#possible_input_error(path, symbol_or_error_class, error_class_or_subclass_parameters = {}, data = nil) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 65

def possible_input_error(
  path,
  symbol_or_error_class,
  error_class_or_subclass_parameters = {},
  data = nil
)
  error_class = if symbol_or_error_class.is_a?(Class)
                  symbol_or_error_class
                else
                  Foobara::DataError.subclass(
                    mod: self,
                    **error_class_or_subclass_parameters,
                    symbol: symbol_or_error_class
                  )
                end

  symbol = error_class.symbol

  possible_error = PossibleError.new(error_class, symbol:, data:)
  possible_error.prepend_path!(path)

  possible_error.manually_added = true
  register_possible_error_class(possible_error)
end

#process_error_constants ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 8

def process_error_constants
  return if @error_constants_processed

  @error_constants_processed = true

  Util.constant_values(self, extends: Foobara::RuntimeError).each do |error_class|
    key = PossibleError.new(error_class).key.to_s

    unless error_context_type_map.key?(key)
      possible_error error_class
    end
  end
end

#register_possible_error_class(possible_error) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 102

def register_possible_error_class(possible_error)
  if possible_error.manually_added
    manually_added_possible_input_errors << possible_error
  end

  error_context_type_map[possible_error.key.to_s] = possible_error
end

#unregister_possible_error_if_registered(possible_error) ⇒ Object 



110
111
112
113
 
# File 'foobara-0.0.110/projects/command/src/command_pattern_implementation/concerns/errors_type.rb', line 110

def unregister_possible_error_if_registered(possible_error)
  key = possible_error.key.to_s
  error_context_type_map.delete(key)
end