Module: Flowy::Result

Included in:
Failure, Success
Defined in:
lib/flowy/result.rb

Overview

Tag module + factory namespace. Both Flowy::Success and Flowy::Failure include this module so ‘result.is_a?(Flowy::Result)` matches either. The instance interface is defined on Success and Failure — see the README.

Class Method Summary collapse

Class Method Details

._collect_results(enumerable) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
 
# File 'lib/flowy/result.rb', line 16

def self._collect_results(enumerable)
  enumerable.map do |item|
    result = yield item
    unless result.is_a?(Flowy::Result)
      raise TypeError,
        "all_success/any_success block must return a Flowy::Result, got #{result.class}"
    end
    result
  end
end

._deep_merge(a, b) ⇒ Object 



6
7
8
9
10
11
12
13
14
 
# File 'lib/flowy/result.rb', line 6

def self._deep_merge(a, b)
  a.merge(b) do |_, va, vb|
    if va.is_a?(Hash) && vb.is_a?(Hash)
      _deep_merge(va, vb)
    else
      vb
    end
  end
end

.failure(error_code:, error_data: {}, error_title: nil, error_description: nil, parent_failure: nil) ⇒ Object 



31
32
33
34
35
36
37
38
39
 
# File 'lib/flowy/result.rb', line 31

def self.failure(error_code:, error_data: {}, error_title: nil, error_description: nil, parent_failure: nil)
  Flowy::Failure.new(
    error_code: error_code,
    error_data: error_data,
    error_title: error_title,
    error_description: error_description,
    parent_failure: parent_failure
  )
end

.success(data: {}, warnings: []) ⇒ Object 



27
28
29
 
# File 'lib/flowy/result.rb', line 27

def self.success(data: {}, warnings: [])
  Flowy::Success.new(data: data, warnings: warnings)
end

.wrap(error_code: :wrapped_error, error_title: nil, **opts) ⇒ Object

‘rescue:` is captured via **opts because `rescue` is a Ruby reserved word and cannot be referenced as a bare local variable inside a method body.



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/flowy/result.rb', line 43

def self.wrap(error_code: :wrapped_error, error_title: nil, **opts)
  unknown = opts.keys - [:rescue]
  raise ArgumentError, "unknown keyword: #{unknown.first}" if unknown.any?

  rescued_classes = Array(opts.fetch(:rescue, [StandardError]))

  value = yield

  return value if value.is_a?(Flowy::Result)

  Flowy::Success.new(data: { value: value })
rescue *rescued_classes => e
  Flowy::Failure.new(
    error_code: error_code,
    error_data: { error_class: e.class.name, message: e.message },
    error_title: error_title,
    error_description: e.message
  )
end