much-result 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 2114bc845c36c3d435c0c3fa6fb6015e75aed0d4a8247aa1c60e15010562dbae
4
- data.tar.gz: 7624db2f9dbc4dc974132f45d10a74c0bca005216a3e0de7ae33f89e8c6a3974
3
+ metadata.gz: c705874728744c7bd72550b17439b2ad5c1105f193eb7e8447c61bce5e9a295a
4
+ data.tar.gz: 1dcbb19d213567c8aa6b4bcbf31c48f8d271043a73006d5b9a663baa405f88ae
5
5
  SHA512:
6
- metadata.gz: 14a5f2dab0534c563be0620fa2f5c8b1bf4743490e533e57ccf048ed965f4e0f8b9b7781037c9c5168278ede24f2ed89311275f65c607c3db1877af416b378bf
7
- data.tar.gz: f4e01c6d702d88800ecab7e26f715535795675e6582c948f601bd02311bea474f5d4e112e2a4b243aade0c33c13554ac1461fada2b4cfebfc985f5bb22afd275
6
+ metadata.gz: c1fd908940151548d51ec9dd9270cba7bd09c959e2c84c04d2d317527f7bd1d495ce53424176ee46e7619f28d87dd1fb27ba227fd97d4b2fcf6154a2e63020df
7
+ data.tar.gz: fc35640da16fbcdd467aa7d764693f5341fb246e9f07d79d0d3e3cafc1a0a38964023e35f3b38fe4853ec42f412a3203b08fa0aab4d4a3acefc41d3346082f89
data/Gemfile CHANGED
@@ -1,7 +1,9 @@
1
+ # frozen_string_literal: true
2
+
1
3
  source "https://rubygems.org"
2
4
 
3
5
  ruby "~> 2.5"
4
6
 
5
7
  gemspec
6
8
 
7
- gem "pry", "~> 0.12.2"
9
+ gem "pry"
data/grep ADDED
@@ -0,0 +1 @@
1
+ Running Rubocop
@@ -1,10 +1,12 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "much-result/version"
2
4
  require "much-result/aggregate"
3
5
  require "much-result/transaction"
4
6
 
5
7
  class MuchResult
6
- SUCCESS = "success".freeze
7
- FAILURE = "failure".freeze
8
+ SUCCESS = "success"
9
+ FAILURE = "failure"
8
10
 
9
11
  Error = Class.new(StandardError)
10
12
  Rollback = Class.new(RuntimeError)
@@ -25,38 +27,38 @@ class MuchResult
25
27
  new(
26
28
  !!value ? MuchResult::SUCCESS : MuchResult::FAILURE,
27
29
  **kargs,
28
- backtrace: backtrace
30
+ backtrace: backtrace,
29
31
  )
30
32
  end
31
33
 
32
34
  def self.tap(backtrace: caller, **kargs)
33
- success(backtrace: backtrace, **kargs).tap { |result|
35
+ success(backtrace: backtrace, **kargs).tap do |result|
34
36
  yield result if block_given?
35
- }
37
+ end
36
38
  end
37
39
 
38
40
  def self.transaction(receiver = nil, backtrace: caller, **kargs, &block)
39
41
  if (transaction_receiver = receiver || default_transaction_receiver).nil?
40
42
  raise(
41
43
  ArgumentError,
42
- "no receiver given and no default_transaction_receiver configured."
44
+ "no receiver given and no default_transaction_receiver configured.",
43
45
  )
44
46
  end
45
47
 
46
- MuchResult::Transaction.(
47
- receiver || default_transaction_receiver,
48
+ MuchResult::Transaction.call(
49
+ transaction_receiver,
48
50
  backtrace: backtrace,
49
51
  **kargs,
50
52
  &block
51
53
  )
52
54
  end
53
55
 
54
- def self.default_transaction_receiver
55
- @default_transaction_receiver
56
+ class << self
57
+ attr_reader :default_transaction_receiver
56
58
  end
57
59
 
58
- def self.default_transaction_receiver=(receiver)
59
- @default_transaction_receiver = receiver
60
+ class << self
61
+ attr_writer :default_transaction_receiver
60
62
  end
61
63
 
62
64
  attr_reader :sub_results, :description, :backtrace
@@ -78,7 +80,7 @@ class MuchResult
78
80
  end
79
81
 
80
82
  def attributes
81
- @data.to_h.reject { |key, _| key.to_s.start_with?("much_result_") }
83
+ @data.to_h.reject{ |key, _| key.to_s.start_with?("much_result_") }
82
84
  end
83
85
 
84
86
  def attribute_names
@@ -88,9 +90,10 @@ class MuchResult
88
90
  def success?
89
91
  if @success_predicate.nil?
90
92
  @success_predicate =
91
- @sub_results.reduce(@result_value == MuchResult::SUCCESS) { |acc, result|
92
- acc && result.success?
93
- }
93
+ @sub_results
94
+ .reduce(@result_value == MuchResult::SUCCESS) do |acc, result|
95
+ acc && result.success?
96
+ end
94
97
  end
95
98
 
96
99
  @success_predicate
@@ -101,35 +104,35 @@ class MuchResult
101
104
  end
102
105
 
103
106
  def capture_for(value, backtrace: caller, **kargs)
104
- self.class.for(value, backtrace: backtrace, **kargs).tap { |result|
107
+ self.class.for(value, backtrace: backtrace, **kargs).tap do |result|
105
108
  @sub_results.push(result)
106
109
  reset_sub_results_cache
107
- }
110
+ end
108
111
  end
109
112
 
110
- def capture_for!(value, backtrace:caller, **kargs)
111
- capture_for(value, **kargs, backtrace: backtrace).tap { |result|
113
+ def capture_for!(value, backtrace: caller, **kargs)
114
+ capture_for(value, **kargs, backtrace: backtrace).tap do |result|
112
115
  raise(result.capture_exception) if result.failure?
113
- }
116
+ end
114
117
  end
115
118
 
116
119
  def capture_for_all(values, backtrace: caller, **kargs)
117
- [*values].map { |value| capture_for(value, **kargs, backtrace: backtrace) }
120
+ [*values].map{ |value| capture_for(value, **kargs, backtrace: backtrace) }
118
121
  end
119
122
 
120
- def capture_for_all!(values, backtrace: caller, **kargs, &block)
121
- capture_for_all(values, **kargs, backtrace: backtrace).tap { |results|
123
+ def capture_for_all!(values, backtrace: caller, **kargs)
124
+ capture_for_all(values, **kargs, backtrace: backtrace).tap do |results|
122
125
  if (first_failure_result = results.detect(&:failure?))
123
126
  raise(first_failure_result.capture_exception)
124
127
  end
125
- }
128
+ end
126
129
  end
127
130
 
128
131
  def capture(backtrace: caller, **kargs)
129
132
  capture_for((yield if block_given?), **kargs, backtrace: backtrace)
130
133
  end
131
134
 
132
- def capture!(backtrace: caller, **kargs, &block)
135
+ def capture!(backtrace: caller, **kargs)
133
136
  capture_for!((yield if block_given?), **kargs, backtrace: backtrace)
134
137
  end
135
138
 
@@ -137,7 +140,7 @@ class MuchResult
137
140
  capture_for_all((yield if block_given?), **kargs, backtrace: backtrace)
138
141
  end
139
142
 
140
- def capture_all!(backtrace: caller, **kargs, &block)
143
+ def capture_all!(backtrace: caller, **kargs)
141
144
  capture_for_all!((yield if block_given?), **kargs, backtrace: backtrace)
142
145
  end
143
146
 
@@ -148,58 +151,60 @@ class MuchResult
148
151
  end
149
152
 
150
153
  def success_sub_results
151
- @success_sub_results ||= @sub_results.select { |result| result.success? }
154
+ @success_sub_results ||= @sub_results.select(&:success?)
152
155
  end
153
156
 
154
157
  def failure_sub_results
155
- @failure_sub_results ||= @sub_results.select { |result| result.failure? }
158
+ @failure_sub_results ||= @sub_results.select(&:failure?)
156
159
  end
157
160
 
158
161
  def all_results
159
162
  @all_results ||=
160
163
  [self] +
161
- @sub_results.flat_map { |result| result.all_results }
164
+ @sub_results.flat_map(&:all_results)
162
165
  end
163
166
 
164
167
  def all_success_results
165
168
  @all_success_results ||=
166
169
  [*(self if success?)] +
167
- @sub_results.flat_map { |result| result.all_success_results }
170
+ @sub_results.flat_map(&:all_success_results)
168
171
  end
169
172
 
170
173
  def all_failure_results
171
174
  @all_failure_results ||=
172
175
  [*(self if failure?)] +
173
- @sub_results.flat_map { |result| result.all_failure_results }
176
+ @sub_results.flat_map(&:all_failure_results)
174
177
  end
175
178
 
176
179
  def get_for_sub_results(attribute_name)
177
- MuchResult::Aggregate.(sub_results.map(&attribute_name.to_sym))
180
+ MuchResult::Aggregate.call(sub_results.map(&attribute_name.to_sym))
178
181
  end
179
182
 
180
183
  def get_for_success_sub_results(attribute_name)
181
- MuchResult::Aggregate.(success_sub_results.map(&attribute_name.to_sym))
184
+ MuchResult::Aggregate.call(success_sub_results.map(&attribute_name.to_sym))
182
185
  end
183
186
 
184
187
  def get_for_failure_sub_results(attribute_name)
185
- MuchResult::Aggregate.(failure_sub_results.map(&attribute_name.to_sym))
188
+ MuchResult::Aggregate.call(failure_sub_results.map(&attribute_name.to_sym))
186
189
  end
187
190
 
188
191
  def get_for_all_results(attribute_name)
189
- MuchResult::Aggregate.(all_results.map(&attribute_name.to_sym))
192
+ MuchResult::Aggregate.call(all_results.map(&attribute_name.to_sym))
190
193
  end
191
194
 
192
195
  def get_for_all_success_results(attribute_name)
193
- MuchResult::Aggregate.(all_success_results.map(&attribute_name.to_sym))
196
+ MuchResult::Aggregate.call(all_success_results.map(&attribute_name.to_sym))
194
197
  end
195
198
 
196
199
  def get_for_all_failure_results(attribute_name)
197
- MuchResult::Aggregate.(all_failure_results.map(&attribute_name.to_sym))
200
+ MuchResult::Aggregate.call(all_failure_results.map(&attribute_name.to_sym))
198
201
  end
199
202
 
203
+ # rubocop:disable Lint/UnusedMethodArgument
200
204
  def to_much_result(backtrace: caller, **kargs)
201
- self.set(**kargs)
205
+ set(**kargs)
202
206
  end
207
+ # rubocop:enable Lint/UnusedMethodArgument
203
208
 
204
209
  def inspect
205
210
  "#<#{self.class}:#{"0x0%x" % (object_id << 1)} "\
@@ -212,7 +217,7 @@ class MuchResult
212
217
  private
213
218
 
214
219
  def build_default_capture_exception
215
- Error.new(description).tap { |exception| exception.set_backtrace(backtrace) }
220
+ Error.new(description).tap{ |exception| exception.set_backtrace(backtrace) }
216
221
  end
217
222
 
218
223
  def reset_sub_results_cache
@@ -1,6 +1,9 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "much-result"
2
4
 
3
5
  class MuchResult; end
6
+
4
7
  class MuchResult::Aggregate
5
8
  def self.call(values)
6
9
  new(values).call
@@ -22,23 +25,23 @@ class MuchResult::Aggregate
22
25
 
23
26
  def combine_in_a_collection(values)
24
27
  if all_hash_values?(values)
25
- values.
26
- reduce { |acc, value| combine_in_a_hash(acc, value) }.
27
- transform_values { |nested_values| combine_values(nested_values) }
28
+ values
29
+ .reduce{ |acc, value| combine_in_a_hash(acc, value) }
30
+ .transform_values{ |nested_values| combine_values(nested_values) }
28
31
  else
29
32
  array_wrap(
30
- values.reduce([]) { |acc, value| combine_in_an_array(acc, value) }
33
+ values.reduce([]){ |acc, value| combine_in_an_array(acc, value) },
31
34
  )
32
35
  end
33
36
  end
34
37
 
35
38
  def combine_in_a_hash(hash1, hash2)
36
- ((h1 = hash1 || {}).keys + (h2 = hash2 || {}).keys).
37
- uniq.
38
- reduce({}) { |hash, key|
39
+ ((h1 = hash1 || {}).keys + (h2 = hash2 || {}).keys)
40
+ .uniq
41
+ .reduce({}) do |hash, key|
39
42
  hash[key] = combine_in_an_array(h1[key], h2[key])
40
43
  hash
41
- }
44
+ end
42
45
  end
43
46
 
44
47
  def combine_in_an_array(acc, other)
@@ -46,12 +49,12 @@ class MuchResult::Aggregate
46
49
  end
47
50
 
48
51
  def array_wrap(value)
49
- value.kind_of?(Array) ? value : [value]
52
+ value.is_a?(Array) ? value : [value]
50
53
  end
51
54
 
52
55
  def all_hash_values?(values)
53
- (compacted = values.compact).reduce(compacted.any?) { |acc, value|
54
- acc && value.kind_of?(::Hash)
55
- }
56
+ (compacted = values.compact).reduce(compacted.any?) do |acc, value|
57
+ acc && value.is_a?(::Hash)
58
+ end
56
59
  end
57
60
  end
@@ -1,6 +1,9 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "much-result"
2
4
 
3
5
  class MuchResult; end
6
+
4
7
  class MuchResult::Transaction
5
8
  def self.halt_throw_value
6
9
  :muchresult_transaction_halt
@@ -27,7 +30,7 @@ class MuchResult::Transaction
27
30
  def call(&block)
28
31
  begin
29
32
  @receiver.transaction do
30
- catch(self.class.halt_throw_value) { block.call(self) }
33
+ catch(self.class.halt_throw_value){ block.call(self) }
31
34
  end
32
35
  rescue MuchResult::Rollback
33
36
  # do nothing
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  class MuchResult
2
- VERSION = "0.1.2"
4
+ VERSION = "0.1.3"
3
5
  end
@@ -1,4 +1,6 @@
1
1
  # -*- encoding: utf-8 -*-
2
+ # frozen_string_literal: true
3
+
2
4
  lib = File.expand_path("../lib", __FILE__)
3
5
  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
4
6
  require "much-result/version"
@@ -13,12 +15,14 @@ Gem::Specification.new do |gem|
13
15
  gem.homepage = "https://github.com/redding/much-result"
14
16
  gem.license = "MIT"
15
17
 
16
- gem.files = `git ls-files | grep "^[^.]"`.split($/)
18
+ gem.files = `git ls-files | grep "^[^.]"`.split($INPUT_RECORD_SEPARATOR)
19
+
17
20
  gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
18
21
  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
19
22
  gem.require_paths = ["lib"]
20
23
 
21
24
  gem.required_ruby_version = "~> 2.5"
22
25
 
23
- gem.add_development_dependency("assert", ["~> 2.18.4"])
26
+ gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
27
+ gem.add_development_dependency("assert", ["~> 2.19.3"])
24
28
  end
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  # this file is automatically required when you run `assert`
2
4
  # put any test helpers here
3
5
 
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "assert/factory"
2
4
  require "much-stub/call"
3
5
 
@@ -11,7 +13,7 @@ module Factory
11
13
  def self.hash_value(with_nested_hash = true)
12
14
  {
13
15
  value1: Factory.value,
14
- value2: with_nested_hash ? Factory.hash_value(false) : Factory.value
16
+ value2: with_nested_hash ? Factory.hash_value(false) : Factory.value,
15
17
  }
16
18
  end
17
19
 
@@ -30,9 +32,9 @@ module Factory
30
32
  @rolled_back = false
31
33
  @last_transaction_call = MuchStub::Call.new(&block)
32
34
  block.call
33
- rescue => exception
35
+ rescue => ex
34
36
  @rolled_back = true
35
- raise exception
37
+ raise ex
36
38
  end
37
39
 
38
40
  def rolled_back?
@@ -1,27 +1,29 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "assert"
2
4
  require "much-result/aggregate"
3
5
 
4
6
  class MuchResult::Aggregate
5
7
  class UnitTests < Assert::Context
6
8
  desc "MuchResult::Aggregate"
7
- subject { unit_class }
9
+ subject{ unit_class }
8
10
 
9
- let(:unit_class) { MuchResult::Aggregate }
11
+ let(:unit_class){ MuchResult::Aggregate }
10
12
 
11
- let(:values1) {
12
- [Factory.value, Factory.value, Factory.value, Hash.new]
13
- }
14
- let(:hash_values1) {
13
+ let(:values1) do
14
+ [Factory.value, Factory.value, Factory.value, {}]
15
+ end
16
+ let(:hash_values1) do
15
17
  [Factory.hash_value, Factory.hash_value, Factory.hash_value]
16
- }
18
+ end
17
19
 
18
20
  should have_imeths :call
19
21
 
20
22
  should "build instances and call them" do
21
- Assert.stub_tap_on_call(subject, :new) { |instance, call|
23
+ Assert.stub_tap_on_call(subject, :new) do |instance, call|
22
24
  @instance_new_call = call
23
- Assert.stub(instance, :call) { @instance_called = true }
24
- }
25
+ Assert.stub(instance, :call){ @instance_called = true }
26
+ end
25
27
 
26
28
  subject.call(values1)
27
29
 
@@ -32,9 +34,9 @@ class MuchResult::Aggregate
32
34
 
33
35
  class InitTests < UnitTests
34
36
  desc "when init"
35
- subject { unit_class.new(init_values) }
37
+ subject{ unit_class.new(init_values) }
36
38
 
37
- let(:init_values) { [values1, hash_values1, [], nil].sample }
39
+ let(:init_values){ [values1, hash_values1, [], nil].sample }
38
40
 
39
41
  should have_imeths :call
40
42
  end
@@ -42,7 +44,7 @@ class MuchResult::Aggregate
42
44
  class CalledWithAnEmptyArrayTests < InitTests
43
45
  desc "and called with an empty Array"
44
46
 
45
- let(:init_values) { [] }
47
+ let(:init_values){ [] }
46
48
  # let(:init_values) { [[], nil, [nil, nil]].sample }
47
49
 
48
50
  should "return an empty Array" do
@@ -53,7 +55,7 @@ class MuchResult::Aggregate
53
55
  class CalledWithASingleNonHashValueTests < InitTests
54
56
  desc "and called with single non-Hash value"
55
57
 
56
- let(:init_values) { [Factory.value, nil].sample }
58
+ let(:init_values){ [Factory.value, nil].sample }
57
59
 
58
60
  should "return the value wrapped in an Array" do
59
61
  assert_that(subject.call).equals([init_values])
@@ -63,8 +65,8 @@ class MuchResult::Aggregate
63
65
  class CalledWithASingleHashValueTests < InitTests
64
66
  desc "and called with single Hash value"
65
67
 
66
- let(:value1) { [Factory.value, nil].sample }
67
- let(:init_values) { { value: value1 } }
68
+ let(:value1){ [Factory.value, nil].sample }
69
+ let(:init_values){ { value: value1 } }
68
70
 
69
71
  should "return the Hash with its values wrapped in an Array" do
70
72
  assert_that(subject.call).equals(value: [value1])
@@ -74,7 +76,7 @@ class MuchResult::Aggregate
74
76
  class CalledWithAMixedValueArrayTests < InitTests
75
77
  desc "and called with a mixed-value Array"
76
78
 
77
- let(:init_values) { [nil, values1, [], { value: 1 }, nil] }
79
+ let(:init_values){ [nil, values1, [], { value: 1 }, nil] }
78
80
 
79
81
  should "combines the values into an Array, flattening any sub-Arrays" do
80
82
  assert_that(subject.call).equals([nil, *values1, { value: 1 }, nil])
@@ -84,17 +86,17 @@ class MuchResult::Aggregate
84
86
  class CalledWithAnAllHashValueArrayTests < InitTests
85
87
  desc "and called with an all-Hash-value Array"
86
88
 
87
- let(:init_values) { [nil] + hash_values1 + [nil] }
89
+ let(:init_values){ [nil] + hash_values1 + [nil] }
88
90
 
89
- let(:expected_aggregate_value) {
91
+ let(:expected_aggregate_value) do
90
92
  {
91
- value1: init_values.map { |hash| (hash || {})[:value1] },
93
+ value1: init_values.map{ |hash| (hash || {})[:value1] },
92
94
  value2: {
93
- value1: init_values.map { |hash| (hash || {}).dig(:value2, :value1) },
94
- value2: init_values.map { |hash| (hash || {}).dig(:value2, :value2) }
95
- }
95
+ value1: init_values.map{ |hash| (hash || {}).dig(:value2, :value1) },
96
+ value2: init_values.map{ |hash| (hash || {}).dig(:value2, :value2) },
97
+ },
96
98
  }
97
- }
99
+ end
98
100
 
99
101
  should "recursively combine the hash values, removing any nils" do
100
102
  assert_that(subject.call).equals(expected_aggregate_value)
@@ -1,17 +1,19 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "assert"
2
4
  require "much-result"
3
5
 
4
6
  class MuchResult
5
7
  class UnitTests < Assert::Context
6
8
  desc "MuchResult"
7
- subject { unit_class }
9
+ subject{ unit_class }
8
10
 
9
- let(:unit_class) { MuchResult }
11
+ let(:unit_class){ MuchResult }
10
12
 
11
- let(:identifier1) { Factory.string }
12
- let(:description1) { Factory.string }
13
- let(:backtrace1) { Factory.backtrace }
14
- let(:value1) { Factory.value }
13
+ let(:identifier1){ Factory.string }
14
+ let(:description1){ Factory.string }
15
+ let(:backtrace1){ Factory.backtrace }
16
+ let(:value1){ Factory.value }
15
17
 
16
18
  should have_imeths :success, :failure, :for, :tap, :transaction
17
19
  should have_accessors :default_transaction_receiver
@@ -75,27 +77,27 @@ class MuchResult
75
77
  should "build instances yielded to a given block" do
76
78
  yielded_result = nil
77
79
  tap_result =
78
- subject.tap { |result|
80
+ subject.tap do |result|
79
81
  yielded_result = result
80
82
 
81
83
  assert_that(result.success?).is_true
82
84
  assert_that(result.sub_results.size).equals(0)
83
85
  assert_that(result.all_results.size).equals(1)
84
- }
86
+ end
85
87
  assert_that(tap_result).is_the_same_as(yielded_result)
86
88
  end
87
89
 
88
90
  should "call transactions on a transaction receiver" do
89
- MuchStub.on_call(MuchResult::Transaction, :call) { |call|
91
+ MuchStub.on_call(MuchResult::Transaction, :call) do |call|
90
92
  @transaction_call = call
91
- }
93
+ end
92
94
 
93
95
  receiver1 = Factory.transaction_receiver
94
96
  kargs1 = {
95
97
  backtrace: Factory.backtrace,
96
- value: value1
98
+ value: value1,
97
99
  }
98
- block1 = -> {}
100
+ block1 = ->{}
99
101
  subject.transaction(receiver1, **kargs1, &block1)
100
102
 
101
103
  assert_that(@transaction_call.pargs).equals([receiver1])
@@ -107,28 +109,28 @@ class MuchResult
107
109
  receiver1 = Factory.transaction_receiver
108
110
  result =
109
111
  subject.transaction(receiver1) do |transaction|
110
- transaction.capture { "something1"}
112
+ transaction.capture{ "something1" }
111
113
  transaction.halt
112
- transaction.capture { "something2" }
114
+ transaction.capture{ "something2" }
113
115
  end
114
116
 
115
117
  assert_that(result.sub_results.size).equals(1)
116
118
  end
117
119
 
118
120
  should "configure default transaction receivers" do
119
- MuchStub.on_call(MuchResult::Transaction, :call) { |call|
121
+ MuchStub.on_call(MuchResult::Transaction, :call) do |call|
120
122
  @transaction_call = call
121
- }
123
+ end
122
124
 
123
125
  receiver1 = Factory.transaction_receiver
124
126
  kargs1 = {
125
127
  backtrace: Factory.backtrace,
126
- value: value1
128
+ value: value1,
127
129
  }
128
- block1 = -> {}
130
+ block1 = ->{}
129
131
 
130
132
  assert_that(subject.default_transaction_receiver).is_nil
131
- assert_that(-> {
133
+ assert_that(->{
132
134
  subject.transaction(**kargs1, &block1)
133
135
  }).raises(ArgumentError)
134
136
 
@@ -147,14 +149,14 @@ class MuchResult
147
149
 
148
150
  class InitTests < UnitTests
149
151
  desc "when init"
150
- subject { unit_class.success }
152
+ subject{ unit_class.success }
151
153
 
152
- let(:failure1) {
154
+ let(:failure1) do
153
155
  unit_class.failure(description: Factory.string)
154
- }
155
- let(:failure2) {
156
+ end
157
+ let(:failure2) do
156
158
  unit_class.failure(exception: StandardError.new(Factory.string))
157
- }
159
+ end
158
160
 
159
161
  should have_imeths :description, :backtrace, :set
160
162
  should have_imeths :attributes, :attribute_names
@@ -167,9 +169,11 @@ class MuchResult
167
169
  should have_imeths :sub_results, :success_sub_results, :failure_sub_results
168
170
  should have_imeths :all_results, :all_success_results, :all_failure_results
169
171
  should have_imeths :get_for_sub_results
170
- should have_imeths :get_for_success_sub_results, :get_for_failure_sub_results
172
+ should have_imeths :get_for_success_sub_results
173
+ should have_imeths :get_for_failure_sub_results
171
174
  should have_imeths :get_for_all_results
172
- should have_imeths :get_for_all_success_results, :get_for_all_failure_results
175
+ should have_imeths :get_for_all_success_results
176
+ should have_imeths :get_for_all_failure_results
173
177
  should have_imeths :to_much_result
174
178
 
175
179
  should "know its attributes" do
@@ -182,7 +186,7 @@ class MuchResult
182
186
  identifier: identifier1,
183
187
  description: description1,
184
188
  backtrace: backtrace1,
185
- value: value1
189
+ value: value1,
186
190
  )
187
191
  assert_that(result.identifier).equals(identifier1)
188
192
  assert_that(result.description).equals(description1)
@@ -234,68 +238,53 @@ class MuchResult
234
238
  assert_that(subject.sub_results.size).equals(1)
235
239
  assert_that(subject.success_sub_results.size).equals(1)
236
240
  assert_that(subject.failure_sub_results.size).equals(0)
237
- assert_that(subject.get_for_sub_results("values")[:value1]).equals(
238
- [
239
- subject.success_sub_results.first.values[:value1]
240
- ])
241
- assert_that(subject.get_for_success_sub_results("values")[:value1]).equals(
242
- [
243
- subject.success_sub_results.first.values[:value1]
244
- ])
245
- assert_that(subject.get_for_failure_sub_results("values")).equals(
246
- [])
241
+ assert_that(subject.get_for_sub_results("values")[:value1])
242
+ .equals([subject.success_sub_results.first.values[:value1]])
243
+ assert_that(subject.get_for_success_sub_results("values")[:value1])
244
+ .equals([subject.success_sub_results.first.values[:value1]])
245
+ assert_that(subject.get_for_failure_sub_results("values"))
246
+ .equals([])
247
247
  assert_that(subject.all_results.size).equals(2)
248
248
  assert_that(subject.all_success_results.size).equals(2)
249
249
  assert_that(subject.all_failure_results.size).equals(0)
250
- assert_that(subject.get_for_all_results("values")[:value1]).equals(
251
- [
252
- nil,
253
- subject.success_sub_results.first.values[:value1]
254
- ])
255
- assert_that(subject.get_for_all_success_results("values")[:value1]).equals(
256
- [
257
- nil,
258
- subject.success_sub_results.first.values[:value1]
259
- ])
260
- assert_that(subject.get_for_all_failure_results("values")).equals(
261
- [])
250
+ assert_that(subject.get_for_all_results("values")[:value1])
251
+ .equals([nil, subject.success_sub_results.first.values[:value1]])
252
+ assert_that(subject.get_for_all_success_results("values")[:value1])
253
+ .equals([nil, subject.success_sub_results.first.values[:value1]])
254
+ assert_that(subject.get_for_all_failure_results("values"))
255
+ .equals([])
262
256
 
263
257
  subject.capture_for(unit_class.failure(values: { value1: Factory.value }))
264
258
  assert_that(subject.success?).is_false
265
259
  assert_that(subject.sub_results.size).equals(2)
266
260
  assert_that(subject.success_sub_results.size).equals(1)
267
261
  assert_that(subject.failure_sub_results.size).equals(1)
268
- assert_that(subject.get_for_sub_results("values")[:value1]).equals(
269
- [
270
- subject.success_sub_results.first.values[:value1],
271
- subject.failure_sub_results.first.values[:value1]
272
- ])
273
- assert_that(subject.get_for_success_sub_results("values")[:value1]).equals(
274
- [
275
- subject.success_sub_results.first.values[:value1]
276
- ])
277
- assert_that(subject.get_for_failure_sub_results("values")[:value1]).equals(
278
- [
279
- subject.failure_sub_results.first.values[:value1]
280
- ])
262
+ assert_that(subject.get_for_sub_results("values")[:value1])
263
+ .equals(
264
+ [
265
+ subject.success_sub_results.first.values[:value1],
266
+ subject.failure_sub_results.first.values[:value1],
267
+ ],
268
+ )
269
+ assert_that(subject.get_for_success_sub_results("values")[:value1])
270
+ .equals([subject.success_sub_results.first.values[:value1]])
271
+ assert_that(subject.get_for_failure_sub_results("values")[:value1])
272
+ .equals([subject.failure_sub_results.first.values[:value1]])
281
273
  assert_that(subject.all_results.size).equals(3)
282
274
  assert_that(subject.all_success_results.size).equals(1)
283
275
  assert_that(subject.all_failure_results.size).equals(2)
284
- assert_that(subject.get_for_all_results("values")[:value1]).equals(
285
- [
286
- nil,
287
- subject.success_sub_results.first.values[:value1],
288
- subject.failure_sub_results.first.values[:value1]
289
- ])
290
- assert_that(subject.get_for_all_success_results("values")[:value1]).equals(
291
- [
292
- subject.success_sub_results.first.values[:value1]
293
- ])
294
- assert_that(subject.get_for_all_failure_results("values")[:value1]).equals(
295
- [
296
- nil,
297
- subject.failure_sub_results.first.values[:value1]
298
- ])
276
+ assert_that(subject.get_for_all_results("values")[:value1])
277
+ .equals(
278
+ [
279
+ nil,
280
+ subject.success_sub_results.first.values[:value1],
281
+ subject.failure_sub_results.first.values[:value1],
282
+ ],
283
+ )
284
+ assert_that(subject.get_for_all_success_results("values")[:value1])
285
+ .equals([subject.success_sub_results.first.values[:value1]])
286
+ assert_that(subject.get_for_all_failure_results("values")[:value1])
287
+ .equals([nil, subject.failure_sub_results.first.values[:value1]])
299
288
 
300
289
  result = unit_class.success
301
290
 
@@ -321,7 +310,7 @@ class MuchResult
321
310
 
322
311
  # Test the default built capture exception.
323
312
  exception =
324
- assert_that(-> {
313
+ assert_that(->{
325
314
  result.capture_for!(failure1)
326
315
  }).raises(MuchResult::Error)
327
316
  assert_that(exception.message).equals(failure1.description)
@@ -337,7 +326,7 @@ class MuchResult
337
326
  # Test that we prefer any set `result.exception` over the default built
338
327
  # capture exception.
339
328
  exception =
340
- assert_that(-> {
329
+ assert_that(->{
341
330
  result.capture_for!(failure2)
342
331
  }).raises(failure2.exception.class)
343
332
  assert_that(exception.message).equals(failure2.exception.message)
@@ -366,8 +355,8 @@ class MuchResult
366
355
  result.capture_for_all(
367
356
  [
368
357
  [true, Factory.integer, Factory.string].sample,
369
- [false, nil].sample
370
- ]
358
+ [false, nil].sample,
359
+ ],
371
360
  )
372
361
  assert_that(result.success?).is_false
373
362
  assert_that(result.sub_results.size).equals(2)
@@ -380,7 +369,7 @@ class MuchResult
380
369
  result = unit_class.success
381
370
 
382
371
  exception =
383
- assert_that(-> {
372
+ assert_that(->{
384
373
  result.capture_for_all!([failure1, failure2])
385
374
  }).raises(MuchResult::Error)
386
375
  assert_that(exception.message).equals(failure1.description)
@@ -395,7 +384,7 @@ class MuchResult
395
384
  end
396
385
 
397
386
  should "capture MuchResults from a block as sub-results" do
398
- subject.capture { unit_class.success }
387
+ subject.capture{ unit_class.success }
399
388
  assert_that(subject.success?).is_true
400
389
  assert_that(subject.sub_results.size).equals(1)
401
390
  assert_that(subject.success_sub_results.size).equals(1)
@@ -404,7 +393,7 @@ class MuchResult
404
393
  assert_that(subject.all_success_results.size).equals(2)
405
394
  assert_that(subject.all_failure_results.size).equals(0)
406
395
 
407
- subject.capture { unit_class.failure }
396
+ subject.capture{ unit_class.failure }
408
397
  assert_that(subject.success?).is_false
409
398
  assert_that(subject.sub_results.size).equals(2)
410
399
  assert_that(subject.success_sub_results.size).equals(1)
@@ -415,7 +404,7 @@ class MuchResult
415
404
 
416
405
  result = unit_class.success
417
406
 
418
- result.capture { [true, Factory.integer, Factory.string].sample }
407
+ result.capture{ [true, Factory.integer, Factory.string].sample }
419
408
  assert_that(result.success?).is_true
420
409
  assert_that(result.sub_results.size).equals(1)
421
410
  assert_that(result.success_sub_results.size).equals(1)
@@ -424,7 +413,7 @@ class MuchResult
424
413
  assert_that(result.all_success_results.size).equals(2)
425
414
  assert_that(result.all_failure_results.size).equals(0)
426
415
 
427
- result.capture { [false, nil].sample }
416
+ result.capture{ [false, nil].sample }
428
417
  assert_that(result.success?).is_false
429
418
  assert_that(result.sub_results.size).equals(2)
430
419
  assert_that(result.success_sub_results.size).equals(1)
@@ -436,8 +425,8 @@ class MuchResult
436
425
  result = unit_class.success
437
426
 
438
427
  exception =
439
- assert_that(-> {
440
- result.capture! { failure1 }
428
+ assert_that(->{
429
+ result.capture!{ failure1 }
441
430
  }).raises(MuchResult::Error)
442
431
  assert_that(exception.message).equals(failure1.description)
443
432
  assert_that(exception.backtrace).equals(failure1.backtrace)
@@ -451,7 +440,7 @@ class MuchResult
451
440
  end
452
441
 
453
442
  should "capture MuchResults from a block from an Array as sub-results" do
454
- subject.capture_all { [unit_class.success, unit_class.failure] }
443
+ subject.capture_all{ [unit_class.success, unit_class.failure] }
455
444
  assert_that(subject.success?).is_false
456
445
  assert_that(subject.sub_results.size).equals(2)
457
446
  assert_that(subject.success_sub_results.size).equals(1)
@@ -465,7 +454,7 @@ class MuchResult
465
454
  result.capture_all do
466
455
  [
467
456
  [true, Factory.integer, Factory.string].sample,
468
- [false, nil].sample
457
+ [false, nil].sample,
469
458
  ]
470
459
  end
471
460
  assert_that(result.success?).is_false
@@ -479,8 +468,8 @@ class MuchResult
479
468
  result = unit_class.success
480
469
 
481
470
  exception =
482
- assert_that(-> {
483
- result.capture_all! { [failure1, failure2] }
471
+ assert_that(->{
472
+ result.capture_all!{ [failure1, failure2] }
484
473
  }).raises(MuchResult::Error)
485
474
  assert_that(exception.message).equals(failure1.description)
486
475
  assert_that(exception.backtrace).equals(failure1.backtrace)
@@ -1,21 +1,23 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "assert"
2
4
  require "much-result/transaction"
3
5
 
4
6
  class MuchResult::Transaction
5
7
  class UnitTests < Assert::Context
6
8
  desc "MuchResult::Transaction"
7
- subject { unit_class }
9
+ subject{ unit_class }
8
10
 
9
- let(:unit_class) { MuchResult::Transaction }
11
+ let(:unit_class){ MuchResult::Transaction }
10
12
 
11
- let(:receiver1) { Factory.transaction_receiver }
12
- let(:value1) { Factory.value }
13
- let(:kargs1) {
14
- { value: value1 }
15
- }
16
- let(:block1) {
17
- ->(transaction) { transaction.set(block_called: true) }
18
- }
13
+ let(:receiver1){ Factory.transaction_receiver }
14
+ let(:value1){ Factory.value }
15
+ let(:kargs1) do
16
+ { value: value1 }
17
+ end
18
+ let(:block1) do
19
+ ->(transaction){ transaction.set(block_called: true) }
20
+ end
19
21
 
20
22
  should have_imeths :halt_throw_value, :call
21
23
 
@@ -24,12 +26,12 @@ class MuchResult::Transaction
24
26
  end
25
27
 
26
28
  should "call transactions on a transaction receiver" do
27
- MuchStub.tap_on_call(unit_class, :new) { |transaction, new_call|
29
+ MuchStub.tap_on_call(unit_class, :new) do |transaction, new_call|
28
30
  @new_call = new_call
29
- MuchStub.on_call(transaction, :call) { |transaction_call|
31
+ MuchStub.on_call(transaction, :call) do |transaction_call|
30
32
  @transaction_call = transaction_call
31
- }
32
- }
33
+ end
34
+ end
33
35
 
34
36
  subject.call(receiver1, **kargs1, &block1)
35
37
 
@@ -41,12 +43,12 @@ class MuchResult::Transaction
41
43
 
42
44
  class InitTests < UnitTests
43
45
  desc "when init"
44
- subject { unit_class.new(receiver1, **kargs1) }
46
+ subject{ unit_class.new(receiver1, **kargs1) }
45
47
 
46
48
  should have_imeths :result, :call, :rollback, :halt
47
49
 
48
50
  should "complain if given a nil receiver" do
49
- assert_that(-> {
51
+ assert_that(->{
50
52
  unit_class.new(nil, **kargs1)
51
53
  }).raises(ArgumentError)
52
54
  end
@@ -65,9 +67,9 @@ class MuchResult::Transaction
65
67
  end
66
68
 
67
69
  should "call transactions on the transaction receiver" do
68
- MuchStub.tap_on_call(block1, :call) { |_, call|
70
+ MuchStub.tap_on_call(block1, :call) do |_, call|
69
71
  @block_call = call
70
- }
72
+ end
71
73
 
72
74
  result = subject.call(&block1)
73
75
 
@@ -78,14 +80,14 @@ class MuchResult::Transaction
78
80
  end
79
81
 
80
82
  should "rollback transactions on the transaction receiver" do
81
- assert_that(-> { subject.rollback }).raises(MuchResult::Rollback)
83
+ assert_that(->{ subject.rollback }).raises(MuchResult::Rollback)
82
84
 
83
- block1 = ->(transaction) { transaction.rollback }
84
- assert_that(-> {subject.call(&block1)}).does_not_raise
85
+ block1 = ->(transaction){ transaction.rollback }
86
+ assert_that(->{ subject.call(&block1) }).does_not_raise
85
87
  assert_that(receiver1.rolled_back?).is_true
86
88
 
87
- block1 = ->(transaction) { raise StandardError }
88
- assert_that(-> {subject.call(&block1)}).raises(StandardError)
89
+ block1 = ->(_transaction){ raise StandardError }
90
+ assert_that(->{ subject.call(&block1) }).raises(StandardError)
89
91
  assert_that(receiver1.rolled_back?).is_true
90
92
 
91
93
  assert_that(subject.result.much_result_transaction_rolled_back).is_true
@@ -94,9 +96,9 @@ class MuchResult::Transaction
94
96
 
95
97
  should "halt transactions" do
96
98
  catch(unit_class.halt_throw_value) do
97
- subject.capture { "something1" }
99
+ subject.capture{ "something1" }
98
100
  subject.halt
99
- subject.capture { "something2" }
101
+ subject.capture{ "something2" }
100
102
  end
101
103
 
102
104
  assert_that(subject.sub_results.size).equals(1)
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: much-result
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.2
4
+ version: 0.1.3
5
5
  platform: ruby
6
6
  authors:
7
7
  - Kelly Redding
@@ -9,22 +9,36 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2020-12-03 00:00:00.000000000 Z
12
+ date: 2021-01-10 00:00:00.000000000 Z
13
13
  dependencies:
14
+ - !ruby/object:Gem::Dependency
15
+ name: much-style-guide
16
+ requirement: !ruby/object:Gem::Requirement
17
+ requirements:
18
+ - - "~>"
19
+ - !ruby/object:Gem::Version
20
+ version: 0.6.0
21
+ type: :development
22
+ prerelease: false
23
+ version_requirements: !ruby/object:Gem::Requirement
24
+ requirements:
25
+ - - "~>"
26
+ - !ruby/object:Gem::Version
27
+ version: 0.6.0
14
28
  - !ruby/object:Gem::Dependency
15
29
  name: assert
16
30
  requirement: !ruby/object:Gem::Requirement
17
31
  requirements:
18
32
  - - "~>"
19
33
  - !ruby/object:Gem::Version
20
- version: 2.18.4
34
+ version: 2.19.3
21
35
  type: :development
22
36
  prerelease: false
23
37
  version_requirements: !ruby/object:Gem::Requirement
24
38
  requirements:
25
39
  - - "~>"
26
40
  - !ruby/object:Gem::Version
27
- version: 2.18.4
41
+ version: 2.19.3
28
42
  description: API for managing the results of operations.
29
43
  email:
30
44
  - kelly@kellyredding.com
@@ -36,6 +50,7 @@ files:
36
50
  - Gemfile
37
51
  - LICENSE
38
52
  - README.md
53
+ - grep
39
54
  - lib/much-result.rb
40
55
  - lib/much-result/aggregate.rb
41
56
  - lib/much-result/transaction.rb
@@ -68,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
68
83
  - !ruby/object:Gem::Version
69
84
  version: '0'
70
85
  requirements: []
71
- rubygems_version: 3.1.2
86
+ rubygems_version: 3.2.4
72
87
  signing_key:
73
88
  specification_version: 4
74
89
  summary: API for managing the results of operations.