much-result 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2114bc845c36c3d435c0c3fa6fb6015e75aed0d4a8247aa1c60e15010562dbae
-  data.tar.gz: 7624db2f9dbc4dc974132f45d10a74c0bca005216a3e0de7ae33f89e8c6a3974
+  metadata.gz: c705874728744c7bd72550b17439b2ad5c1105f193eb7e8447c61bce5e9a295a
+  data.tar.gz: 1dcbb19d213567c8aa6b4bcbf31c48f8d271043a73006d5b9a663baa405f88ae
 SHA512:
-  metadata.gz: 14a5f2dab0534c563be0620fa2f5c8b1bf4743490e533e57ccf048ed965f4e0f8b9b7781037c9c5168278ede24f2ed89311275f65c607c3db1877af416b378bf
-  data.tar.gz: f4e01c6d702d88800ecab7e26f715535795675e6582c948f601bd02311bea474f5d4e112e2a4b243aade0c33c13554ac1461fada2b4cfebfc985f5bb22afd275
+  metadata.gz: c1fd908940151548d51ec9dd9270cba7bd09c959e2c84c04d2d317527f7bd1d495ce53424176ee46e7619f28d87dd1fb27ba227fd97d4b2fcf6154a2e63020df
+  data.tar.gz: fc35640da16fbcdd467aa7d764693f5341fb246e9f07d79d0d3e3cafc1a0a38964023e35f3b38fe4853ec42f412a3203b08fa0aab4d4a3acefc41d3346082f89

data/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 ruby "~> 2.5"
 
 gemspec
 
-gem "pry", "~> 0.12.2"
+gem "pry"

data/grep

@@ -0,0 +1 @@
+Running Rubocop

data/lib/much-result.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "much-result/version"
 require "much-result/aggregate"
 require "much-result/transaction"
 
 class MuchResult
-  SUCCESS = "success".freeze
-  FAILURE = "failure".freeze
+  SUCCESS = "success"
+  FAILURE = "failure"
 
   Error    = Class.new(StandardError)
   Rollback = Class.new(RuntimeError)
@@ -25,38 +27,38 @@ class MuchResult
     new(
       !!value ? MuchResult::SUCCESS : MuchResult::FAILURE,
       **kargs,
-      backtrace: backtrace
+      backtrace: backtrace,
     )
   end
 
   def self.tap(backtrace: caller, **kargs)
-    success(backtrace: backtrace, **kargs).tap { |result|
+    success(backtrace: backtrace, **kargs).tap do |result|
       yield result if block_given?
-    }
+    end
   end
 
   def self.transaction(receiver = nil, backtrace: caller, **kargs, &block)
     if (transaction_receiver = receiver || default_transaction_receiver).nil?
       raise(
         ArgumentError,
-        "no receiver given and no default_transaction_receiver configured."
+        "no receiver given and no default_transaction_receiver configured.",
       )
     end
 
-    MuchResult::Transaction.(
-      receiver || default_transaction_receiver,
+    MuchResult::Transaction.call(
+      transaction_receiver,
       backtrace: backtrace,
       **kargs,
       &block
     )
   end
 
-  def self.default_transaction_receiver
-    @default_transaction_receiver
+  class << self
+    attr_reader :default_transaction_receiver
   end
 
-  def self.default_transaction_receiver=(receiver)
-    @default_transaction_receiver = receiver
+  class << self
+    attr_writer :default_transaction_receiver
   end
 
   attr_reader :sub_results, :description, :backtrace
@@ -78,7 +80,7 @@ class MuchResult
   end
 
   def attributes
-    @data.to_h.reject { |key, _| key.to_s.start_with?("much_result_") }
+    @data.to_h.reject{ |key, _| key.to_s.start_with?("much_result_") }
   end
 
   def attribute_names
@@ -88,9 +90,10 @@ class MuchResult
   def success?
     if @success_predicate.nil?
       @success_predicate =
-        @sub_results.reduce(@result_value == MuchResult::SUCCESS) { |acc, result|
-          acc && result.success?
-        }
+        @sub_results
+          .reduce(@result_value == MuchResult::SUCCESS) do |acc, result|
+            acc && result.success?
+          end
     end
 
     @success_predicate
@@ -101,35 +104,35 @@ class MuchResult
   end
 
   def capture_for(value, backtrace: caller, **kargs)
-    self.class.for(value, backtrace: backtrace, **kargs).tap { |result|
+    self.class.for(value, backtrace: backtrace, **kargs).tap do |result|
       @sub_results.push(result)
       reset_sub_results_cache
-    }
+    end
   end
 
-  def capture_for!(value, backtrace:caller, **kargs)
-    capture_for(value, **kargs, backtrace: backtrace).tap { |result|
+  def capture_for!(value, backtrace: caller, **kargs)
+    capture_for(value, **kargs, backtrace: backtrace).tap do |result|
       raise(result.capture_exception) if result.failure?
-    }
+    end
   end
 
   def capture_for_all(values, backtrace: caller, **kargs)
-    [*values].map { |value| capture_for(value, **kargs, backtrace: backtrace) }
+    [*values].map{ |value| capture_for(value, **kargs, backtrace: backtrace) }
   end
 
-  def capture_for_all!(values, backtrace: caller, **kargs, &block)
-    capture_for_all(values, **kargs, backtrace: backtrace).tap { |results|
+  def capture_for_all!(values, backtrace: caller, **kargs)
+    capture_for_all(values, **kargs, backtrace: backtrace).tap do |results|
       if (first_failure_result = results.detect(&:failure?))
         raise(first_failure_result.capture_exception)
       end
-    }
+    end
   end
 
   def capture(backtrace: caller, **kargs)
     capture_for((yield if block_given?), **kargs, backtrace: backtrace)
   end
 
-  def capture!(backtrace: caller, **kargs, &block)
+  def capture!(backtrace: caller, **kargs)
     capture_for!((yield if block_given?), **kargs, backtrace: backtrace)
   end
 
@@ -137,7 +140,7 @@ class MuchResult
     capture_for_all((yield if block_given?), **kargs, backtrace: backtrace)
   end
 
-  def capture_all!(backtrace: caller, **kargs, &block)
+  def capture_all!(backtrace: caller, **kargs)
     capture_for_all!((yield if block_given?), **kargs, backtrace: backtrace)
   end
 
@@ -148,58 +151,60 @@ class MuchResult
   end
 
   def success_sub_results
-    @success_sub_results ||= @sub_results.select { |result| result.success? }
+    @success_sub_results ||= @sub_results.select(&:success?)
   end
 
   def failure_sub_results
-    @failure_sub_results ||= @sub_results.select { |result| result.failure? }
+    @failure_sub_results ||= @sub_results.select(&:failure?)
   end
 
   def all_results
     @all_results ||=
       [self] +
-      @sub_results.flat_map { |result| result.all_results }
+      @sub_results.flat_map(&:all_results)
   end
 
   def all_success_results
     @all_success_results ||=
       [*(self if success?)] +
-      @sub_results.flat_map { |result| result.all_success_results }
+      @sub_results.flat_map(&:all_success_results)
   end
 
   def all_failure_results
     @all_failure_results ||=
       [*(self if failure?)] +
-      @sub_results.flat_map { |result| result.all_failure_results }
+      @sub_results.flat_map(&:all_failure_results)
   end
 
   def get_for_sub_results(attribute_name)
-    MuchResult::Aggregate.(sub_results.map(&attribute_name.to_sym))
+    MuchResult::Aggregate.call(sub_results.map(&attribute_name.to_sym))
   end
 
   def get_for_success_sub_results(attribute_name)
-    MuchResult::Aggregate.(success_sub_results.map(&attribute_name.to_sym))
+    MuchResult::Aggregate.call(success_sub_results.map(&attribute_name.to_sym))
   end
 
   def get_for_failure_sub_results(attribute_name)
-    MuchResult::Aggregate.(failure_sub_results.map(&attribute_name.to_sym))
+    MuchResult::Aggregate.call(failure_sub_results.map(&attribute_name.to_sym))
   end
 
   def get_for_all_results(attribute_name)
-    MuchResult::Aggregate.(all_results.map(&attribute_name.to_sym))
+    MuchResult::Aggregate.call(all_results.map(&attribute_name.to_sym))
   end
 
   def get_for_all_success_results(attribute_name)
-    MuchResult::Aggregate.(all_success_results.map(&attribute_name.to_sym))
+    MuchResult::Aggregate.call(all_success_results.map(&attribute_name.to_sym))
   end
 
   def get_for_all_failure_results(attribute_name)
-    MuchResult::Aggregate.(all_failure_results.map(&attribute_name.to_sym))
+    MuchResult::Aggregate.call(all_failure_results.map(&attribute_name.to_sym))
   end
 
+  # rubocop:disable Lint/UnusedMethodArgument
   def to_much_result(backtrace: caller, **kargs)
-    self.set(**kargs)
+    set(**kargs)
   end
+  # rubocop:enable Lint/UnusedMethodArgument
 
   def inspect
     "#<#{self.class}:#{"0x0%x" % (object_id << 1)} "\
@@ -212,7 +217,7 @@ class MuchResult
   private
 
   def build_default_capture_exception
-    Error.new(description).tap { |exception| exception.set_backtrace(backtrace) }
+    Error.new(description).tap{ |exception| exception.set_backtrace(backtrace) }
   end
 
   def reset_sub_results_cache

data/lib/much-result/aggregate.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "much-result"
 
 class MuchResult; end
+
 class MuchResult::Aggregate
   def self.call(values)
     new(values).call
@@ -22,23 +25,23 @@ class MuchResult::Aggregate
 
   def combine_in_a_collection(values)
     if all_hash_values?(values)
-      values.
-        reduce { |acc, value| combine_in_a_hash(acc, value) }.
-        transform_values { |nested_values| combine_values(nested_values) }
+      values
+        .reduce{ |acc, value| combine_in_a_hash(acc, value) }
+        .transform_values{ |nested_values| combine_values(nested_values) }
     else
       array_wrap(
-        values.reduce([]) { |acc, value| combine_in_an_array(acc, value) }
+        values.reduce([]){ |acc, value| combine_in_an_array(acc, value) },
       )
     end
   end
 
   def combine_in_a_hash(hash1, hash2)
-    ((h1 = hash1 || {}).keys + (h2 = hash2 || {}).keys).
-      uniq.
-      reduce({}) { |hash, key|
+    ((h1 = hash1 || {}).keys + (h2 = hash2 || {}).keys)
+      .uniq
+      .reduce({}) do |hash, key|
         hash[key] = combine_in_an_array(h1[key], h2[key])
         hash
-      }
+      end
   end
 
   def combine_in_an_array(acc, other)
@@ -46,12 +49,12 @@ class MuchResult::Aggregate
   end
 
   def array_wrap(value)
-    value.kind_of?(Array) ? value : [value]
+    value.is_a?(Array) ? value : [value]
   end
 
   def all_hash_values?(values)
-    (compacted = values.compact).reduce(compacted.any?) { |acc, value|
-      acc && value.kind_of?(::Hash)
-    }
+    (compacted = values.compact).reduce(compacted.any?) do |acc, value|
+      acc && value.is_a?(::Hash)
+    end
   end
 end

data/lib/much-result/transaction.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "much-result"
 
 class MuchResult; end
+
 class MuchResult::Transaction
   def self.halt_throw_value
     :muchresult_transaction_halt
@@ -27,7 +30,7 @@ class MuchResult::Transaction
   def call(&block)
     begin
       @receiver.transaction do
-        catch(self.class.halt_throw_value) { block.call(self) }
+        catch(self.class.halt_throw_value){ block.call(self) }
       end
     rescue MuchResult::Rollback
       # do nothing

data/lib/much-result/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MuchResult
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/much-result.gemspec

@@ -1,4 +1,6 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-result/version"
@@ -13,12 +15,14 @@ Gem::Specification.new do |gem|
   gem.homepage    = "https://github.com/redding/much-result"
   gem.license     = "MIT"
 
-  gem.files         = `git ls-files | grep "^[^.]"`.split($/)
+  gem.files = `git ls-files | grep "^[^.]"`.split($INPUT_RECORD_SEPARATOR)
+
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_development_dependency("assert", ["~> 2.18.4"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.3"])
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 

data/test/support/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/factory"
 require "much-stub/call"
 
@@ -11,7 +13,7 @@ module Factory
   def self.hash_value(with_nested_hash = true)
     {
       value1: Factory.value,
-      value2: with_nested_hash ? Factory.hash_value(false) : Factory.value
+      value2: with_nested_hash ? Factory.hash_value(false) : Factory.value,
     }
   end
 
@@ -30,9 +32,9 @@ module Factory
       @rolled_back = false
       @last_transaction_call = MuchStub::Call.new(&block)
       block.call
-    rescue => exception
+    rescue => ex
       @rolled_back = true
-      raise exception
+      raise ex
     end
 
     def rolled_back?

data/test/unit/aggregate_tests.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-result/aggregate"
 
 class MuchResult::Aggregate
   class UnitTests < Assert::Context
     desc "MuchResult::Aggregate"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { MuchResult::Aggregate }
+    let(:unit_class){ MuchResult::Aggregate }
 
-    let(:values1) {
-      [Factory.value, Factory.value, Factory.value, Hash.new]
-    }
-    let(:hash_values1) {
+    let(:values1) do
+      [Factory.value, Factory.value, Factory.value, {}]
+    end
+    let(:hash_values1) do
       [Factory.hash_value, Factory.hash_value, Factory.hash_value]
-    }
+    end
 
     should have_imeths :call
 
     should "build instances and call them" do
-      Assert.stub_tap_on_call(subject, :new) { |instance, call|
+      Assert.stub_tap_on_call(subject, :new) do |instance, call|
         @instance_new_call = call
-        Assert.stub(instance, :call) { @instance_called = true }
-      }
+        Assert.stub(instance, :call){ @instance_called = true }
+      end
 
       subject.call(values1)
 
@@ -32,9 +34,9 @@ class MuchResult::Aggregate
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(init_values) }
+    subject{ unit_class.new(init_values) }
 
-    let(:init_values) { [values1, hash_values1, [], nil].sample }
+    let(:init_values){ [values1, hash_values1, [], nil].sample }
 
     should have_imeths :call
   end
@@ -42,7 +44,7 @@ class MuchResult::Aggregate
   class CalledWithAnEmptyArrayTests < InitTests
     desc "and called with an empty Array"
 
-    let(:init_values) { [] }
+    let(:init_values){ [] }
     # let(:init_values) { [[], nil, [nil, nil]].sample }
 
     should "return an empty Array" do
@@ -53,7 +55,7 @@ class MuchResult::Aggregate
   class CalledWithASingleNonHashValueTests < InitTests
     desc "and called with single non-Hash value"
 
-    let(:init_values) { [Factory.value, nil].sample }
+    let(:init_values){ [Factory.value, nil].sample }
 
     should "return the value wrapped in an Array" do
       assert_that(subject.call).equals([init_values])
@@ -63,8 +65,8 @@ class MuchResult::Aggregate
   class CalledWithASingleHashValueTests < InitTests
     desc "and called with single Hash value"
 
-    let(:value1) { [Factory.value, nil].sample }
-    let(:init_values) { { value: value1 } }
+    let(:value1){ [Factory.value, nil].sample }
+    let(:init_values){ { value: value1 } }
 
     should "return the Hash with its values wrapped in an Array" do
       assert_that(subject.call).equals(value: [value1])
@@ -74,7 +76,7 @@ class MuchResult::Aggregate
   class CalledWithAMixedValueArrayTests < InitTests
     desc "and called with a mixed-value Array"
 
-    let(:init_values) { [nil, values1, [], { value: 1 }, nil] }
+    let(:init_values){ [nil, values1, [], { value: 1 }, nil] }
 
     should "combines the values into an Array, flattening any sub-Arrays" do
       assert_that(subject.call).equals([nil, *values1, { value: 1 }, nil])
@@ -84,17 +86,17 @@ class MuchResult::Aggregate
   class CalledWithAnAllHashValueArrayTests < InitTests
     desc "and called with an all-Hash-value Array"
 
-    let(:init_values) { [nil] + hash_values1 + [nil] }
+    let(:init_values){ [nil] + hash_values1 + [nil] }
 
-    let(:expected_aggregate_value) {
+    let(:expected_aggregate_value) do
       {
-        value1: init_values.map { |hash| (hash || {})[:value1] },
+        value1: init_values.map{ |hash| (hash || {})[:value1] },
         value2: {
-          value1: init_values.map { |hash| (hash || {}).dig(:value2, :value1) },
-          value2: init_values.map { |hash| (hash || {}).dig(:value2, :value2) }
-        }
+          value1: init_values.map{ |hash| (hash || {}).dig(:value2, :value1) },
+          value2: init_values.map{ |hash| (hash || {}).dig(:value2, :value2) },
+        },
       }
-    }
+    end
 
     should "recursively combine the hash values, removing any nils" do
       assert_that(subject.call).equals(expected_aggregate_value)

data/test/unit/much-result_tests.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-result"
 
 class MuchResult
   class UnitTests < Assert::Context
     desc "MuchResult"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { MuchResult }
+    let(:unit_class){ MuchResult }
 
-    let(:identifier1) { Factory.string }
-    let(:description1) { Factory.string }
-    let(:backtrace1) { Factory.backtrace }
-    let(:value1) { Factory.value }
+    let(:identifier1){ Factory.string }
+    let(:description1){ Factory.string }
+    let(:backtrace1){ Factory.backtrace }
+    let(:value1){ Factory.value }
 
     should have_imeths :success, :failure, :for, :tap, :transaction
     should have_accessors :default_transaction_receiver
@@ -75,27 +77,27 @@ class MuchResult
     should "build instances yielded to a given block" do
       yielded_result = nil
       tap_result =
-        subject.tap { |result|
+        subject.tap do |result|
           yielded_result = result
 
           assert_that(result.success?).is_true
           assert_that(result.sub_results.size).equals(0)
           assert_that(result.all_results.size).equals(1)
-        }
+        end
       assert_that(tap_result).is_the_same_as(yielded_result)
     end
 
     should "call transactions on a transaction receiver" do
-      MuchStub.on_call(MuchResult::Transaction, :call) { |call|
+      MuchStub.on_call(MuchResult::Transaction, :call) do |call|
         @transaction_call = call
-      }
+      end
 
       receiver1 = Factory.transaction_receiver
       kargs1 = {
         backtrace: Factory.backtrace,
-        value: value1
+        value: value1,
       }
-      block1 = -> {}
+      block1 = ->{}
       subject.transaction(receiver1, **kargs1, &block1)
 
       assert_that(@transaction_call.pargs).equals([receiver1])
@@ -107,28 +109,28 @@ class MuchResult
       receiver1 = Factory.transaction_receiver
       result =
         subject.transaction(receiver1) do |transaction|
-          transaction.capture { "something1"}
+          transaction.capture{ "something1" }
           transaction.halt
-          transaction.capture { "something2" }
+          transaction.capture{ "something2" }
         end
 
       assert_that(result.sub_results.size).equals(1)
     end
 
     should "configure default transaction receivers" do
-      MuchStub.on_call(MuchResult::Transaction, :call) { |call|
+      MuchStub.on_call(MuchResult::Transaction, :call) do |call|
         @transaction_call = call
-      }
+      end
 
       receiver1 = Factory.transaction_receiver
       kargs1 = {
         backtrace: Factory.backtrace,
-        value: value1
+        value: value1,
       }
-      block1 = -> {}
+      block1 = ->{}
 
       assert_that(subject.default_transaction_receiver).is_nil
-      assert_that(-> {
+      assert_that(->{
         subject.transaction(**kargs1, &block1)
       }).raises(ArgumentError)
 
@@ -147,14 +149,14 @@ class MuchResult
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.success }
+    subject{ unit_class.success }
 
-    let(:failure1) {
+    let(:failure1) do
       unit_class.failure(description: Factory.string)
-    }
-    let(:failure2) {
+    end
+    let(:failure2) do
       unit_class.failure(exception: StandardError.new(Factory.string))
-    }
+    end
 
     should have_imeths :description, :backtrace, :set
     should have_imeths :attributes, :attribute_names
@@ -167,9 +169,11 @@ class MuchResult
     should have_imeths :sub_results, :success_sub_results, :failure_sub_results
     should have_imeths :all_results, :all_success_results, :all_failure_results
     should have_imeths :get_for_sub_results
-    should have_imeths :get_for_success_sub_results, :get_for_failure_sub_results
+    should have_imeths :get_for_success_sub_results
+    should have_imeths :get_for_failure_sub_results
     should have_imeths :get_for_all_results
-    should have_imeths :get_for_all_success_results, :get_for_all_failure_results
+    should have_imeths :get_for_all_success_results
+    should have_imeths :get_for_all_failure_results
     should have_imeths :to_much_result
 
     should "know its attributes" do
@@ -182,7 +186,7 @@ class MuchResult
           identifier: identifier1,
           description: description1,
           backtrace: backtrace1,
-          value: value1
+          value: value1,
         )
       assert_that(result.identifier).equals(identifier1)
       assert_that(result.description).equals(description1)
@@ -234,68 +238,53 @@ class MuchResult
       assert_that(subject.sub_results.size).equals(1)
       assert_that(subject.success_sub_results.size).equals(1)
       assert_that(subject.failure_sub_results.size).equals(0)
-      assert_that(subject.get_for_sub_results("values")[:value1]).equals(
-        [
-          subject.success_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_success_sub_results("values")[:value1]).equals(
-        [
-          subject.success_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_failure_sub_results("values")).equals(
-        [])
+      assert_that(subject.get_for_sub_results("values")[:value1])
+        .equals([subject.success_sub_results.first.values[:value1]])
+      assert_that(subject.get_for_success_sub_results("values")[:value1])
+        .equals([subject.success_sub_results.first.values[:value1]])
+      assert_that(subject.get_for_failure_sub_results("values"))
+        .equals([])
       assert_that(subject.all_results.size).equals(2)
       assert_that(subject.all_success_results.size).equals(2)
       assert_that(subject.all_failure_results.size).equals(0)
-      assert_that(subject.get_for_all_results("values")[:value1]).equals(
-        [
-          nil,
-          subject.success_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_all_success_results("values")[:value1]).equals(
-        [
-          nil,
-          subject.success_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_all_failure_results("values")).equals(
-        [])
+      assert_that(subject.get_for_all_results("values")[:value1])
+        .equals([nil, subject.success_sub_results.first.values[:value1]])
+      assert_that(subject.get_for_all_success_results("values")[:value1])
+        .equals([nil, subject.success_sub_results.first.values[:value1]])
+      assert_that(subject.get_for_all_failure_results("values"))
+        .equals([])
 
       subject.capture_for(unit_class.failure(values: { value1: Factory.value }))
       assert_that(subject.success?).is_false
       assert_that(subject.sub_results.size).equals(2)
       assert_that(subject.success_sub_results.size).equals(1)
       assert_that(subject.failure_sub_results.size).equals(1)
-      assert_that(subject.get_for_sub_results("values")[:value1]).equals(
-        [
-          subject.success_sub_results.first.values[:value1],
-          subject.failure_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_success_sub_results("values")[:value1]).equals(
-        [
-          subject.success_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_failure_sub_results("values")[:value1]).equals(
-        [
-          subject.failure_sub_results.first.values[:value1]
-        ])
+      assert_that(subject.get_for_sub_results("values")[:value1])
+        .equals(
+          [
+            subject.success_sub_results.first.values[:value1],
+            subject.failure_sub_results.first.values[:value1],
+          ],
+        )
+      assert_that(subject.get_for_success_sub_results("values")[:value1])
+        .equals([subject.success_sub_results.first.values[:value1]])
+      assert_that(subject.get_for_failure_sub_results("values")[:value1])
+        .equals([subject.failure_sub_results.first.values[:value1]])
       assert_that(subject.all_results.size).equals(3)
       assert_that(subject.all_success_results.size).equals(1)
       assert_that(subject.all_failure_results.size).equals(2)
-      assert_that(subject.get_for_all_results("values")[:value1]).equals(
-        [
-          nil,
-          subject.success_sub_results.first.values[:value1],
-          subject.failure_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_all_success_results("values")[:value1]).equals(
-        [
-          subject.success_sub_results.first.values[:value1]
-        ])
-      assert_that(subject.get_for_all_failure_results("values")[:value1]).equals(
-        [
-          nil,
-          subject.failure_sub_results.first.values[:value1]
-        ])
+      assert_that(subject.get_for_all_results("values")[:value1])
+        .equals(
+          [
+            nil,
+            subject.success_sub_results.first.values[:value1],
+            subject.failure_sub_results.first.values[:value1],
+          ],
+        )
+      assert_that(subject.get_for_all_success_results("values")[:value1])
+        .equals([subject.success_sub_results.first.values[:value1]])
+      assert_that(subject.get_for_all_failure_results("values")[:value1])
+        .equals([nil, subject.failure_sub_results.first.values[:value1]])
 
       result = unit_class.success
 
@@ -321,7 +310,7 @@ class MuchResult
 
       # Test the default built capture exception.
       exception =
-        assert_that(-> {
+        assert_that(->{
           result.capture_for!(failure1)
         }).raises(MuchResult::Error)
       assert_that(exception.message).equals(failure1.description)
@@ -337,7 +326,7 @@ class MuchResult
       # Test that we prefer any set `result.exception` over the default built
       # capture exception.
       exception =
-        assert_that(-> {
+        assert_that(->{
           result.capture_for!(failure2)
         }).raises(failure2.exception.class)
       assert_that(exception.message).equals(failure2.exception.message)
@@ -366,8 +355,8 @@ class MuchResult
       result.capture_for_all(
         [
           [true, Factory.integer, Factory.string].sample,
-          [false, nil].sample
-        ]
+          [false, nil].sample,
+        ],
       )
       assert_that(result.success?).is_false
       assert_that(result.sub_results.size).equals(2)
@@ -380,7 +369,7 @@ class MuchResult
       result = unit_class.success
 
       exception =
-        assert_that(-> {
+        assert_that(->{
           result.capture_for_all!([failure1, failure2])
         }).raises(MuchResult::Error)
       assert_that(exception.message).equals(failure1.description)
@@ -395,7 +384,7 @@ class MuchResult
     end
 
     should "capture MuchResults from a block as sub-results" do
-      subject.capture { unit_class.success }
+      subject.capture{ unit_class.success }
       assert_that(subject.success?).is_true
       assert_that(subject.sub_results.size).equals(1)
       assert_that(subject.success_sub_results.size).equals(1)
@@ -404,7 +393,7 @@ class MuchResult
       assert_that(subject.all_success_results.size).equals(2)
       assert_that(subject.all_failure_results.size).equals(0)
 
-      subject.capture { unit_class.failure }
+      subject.capture{ unit_class.failure }
       assert_that(subject.success?).is_false
       assert_that(subject.sub_results.size).equals(2)
       assert_that(subject.success_sub_results.size).equals(1)
@@ -415,7 +404,7 @@ class MuchResult
 
       result = unit_class.success
 
-      result.capture { [true, Factory.integer, Factory.string].sample }
+      result.capture{ [true, Factory.integer, Factory.string].sample }
       assert_that(result.success?).is_true
       assert_that(result.sub_results.size).equals(1)
       assert_that(result.success_sub_results.size).equals(1)
@@ -424,7 +413,7 @@ class MuchResult
       assert_that(result.all_success_results.size).equals(2)
       assert_that(result.all_failure_results.size).equals(0)
 
-      result.capture { [false, nil].sample }
+      result.capture{ [false, nil].sample }
       assert_that(result.success?).is_false
       assert_that(result.sub_results.size).equals(2)
       assert_that(result.success_sub_results.size).equals(1)
@@ -436,8 +425,8 @@ class MuchResult
       result = unit_class.success
 
       exception =
-        assert_that(-> {
-          result.capture! { failure1 }
+        assert_that(->{
+          result.capture!{ failure1 }
         }).raises(MuchResult::Error)
       assert_that(exception.message).equals(failure1.description)
       assert_that(exception.backtrace).equals(failure1.backtrace)
@@ -451,7 +440,7 @@ class MuchResult
     end
 
     should "capture MuchResults from a block from an Array as sub-results" do
-      subject.capture_all { [unit_class.success, unit_class.failure] }
+      subject.capture_all{ [unit_class.success, unit_class.failure] }
       assert_that(subject.success?).is_false
       assert_that(subject.sub_results.size).equals(2)
       assert_that(subject.success_sub_results.size).equals(1)
@@ -465,7 +454,7 @@ class MuchResult
       result.capture_all do
         [
           [true, Factory.integer, Factory.string].sample,
-          [false, nil].sample
+          [false, nil].sample,
         ]
       end
       assert_that(result.success?).is_false
@@ -479,8 +468,8 @@ class MuchResult
       result = unit_class.success
 
       exception =
-        assert_that(-> {
-          result.capture_all! { [failure1, failure2] }
+        assert_that(->{
+          result.capture_all!{ [failure1, failure2] }
         }).raises(MuchResult::Error)
       assert_that(exception.message).equals(failure1.description)
       assert_that(exception.backtrace).equals(failure1.backtrace)

data/test/unit/transaction_tests.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-result/transaction"
 
 class MuchResult::Transaction
   class UnitTests < Assert::Context
     desc "MuchResult::Transaction"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { MuchResult::Transaction }
+    let(:unit_class){ MuchResult::Transaction }
 
-    let(:receiver1) { Factory.transaction_receiver }
-    let(:value1) { Factory.value }
-    let(:kargs1) {
-      { value:  value1 }
-    }
-    let(:block1) {
-      ->(transaction) { transaction.set(block_called: true) }
-    }
+    let(:receiver1){ Factory.transaction_receiver }
+    let(:value1){ Factory.value }
+    let(:kargs1) do
+      { value: value1 }
+    end
+    let(:block1) do
+      ->(transaction){ transaction.set(block_called: true) }
+    end
 
     should have_imeths :halt_throw_value, :call
 
@@ -24,12 +26,12 @@ class MuchResult::Transaction
     end
 
     should "call transactions on a transaction receiver" do
-      MuchStub.tap_on_call(unit_class, :new) { |transaction, new_call|
+      MuchStub.tap_on_call(unit_class, :new) do |transaction, new_call|
         @new_call = new_call
-        MuchStub.on_call(transaction, :call) { |transaction_call|
+        MuchStub.on_call(transaction, :call) do |transaction_call|
           @transaction_call = transaction_call
-        }
-      }
+        end
+      end
 
       subject.call(receiver1, **kargs1, &block1)
 
@@ -41,12 +43,12 @@ class MuchResult::Transaction
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(receiver1, **kargs1) }
+    subject{ unit_class.new(receiver1, **kargs1) }
 
     should have_imeths :result, :call, :rollback, :halt
 
     should "complain if given a nil receiver" do
-      assert_that(-> {
+      assert_that(->{
         unit_class.new(nil, **kargs1)
       }).raises(ArgumentError)
     end
@@ -65,9 +67,9 @@ class MuchResult::Transaction
     end
 
     should "call transactions on the transaction receiver" do
-      MuchStub.tap_on_call(block1, :call) { |_, call|
+      MuchStub.tap_on_call(block1, :call) do |_, call|
         @block_call = call
-      }
+      end
 
       result = subject.call(&block1)
 
@@ -78,14 +80,14 @@ class MuchResult::Transaction
     end
 
     should "rollback transactions on the transaction receiver" do
-      assert_that(-> { subject.rollback }).raises(MuchResult::Rollback)
+      assert_that(->{ subject.rollback }).raises(MuchResult::Rollback)
 
-      block1 = ->(transaction) { transaction.rollback }
-      assert_that(-> {subject.call(&block1)}).does_not_raise
+      block1 = ->(transaction){ transaction.rollback }
+      assert_that(->{ subject.call(&block1) }).does_not_raise
       assert_that(receiver1.rolled_back?).is_true
 
-      block1 = ->(transaction) { raise StandardError }
-      assert_that(-> {subject.call(&block1)}).raises(StandardError)
+      block1 = ->(_transaction){ raise StandardError }
+      assert_that(->{ subject.call(&block1) }).raises(StandardError)
       assert_that(receiver1.rolled_back?).is_true
 
       assert_that(subject.result.much_result_transaction_rolled_back).is_true
@@ -94,9 +96,9 @@ class MuchResult::Transaction
 
     should "halt transactions" do
       catch(unit_class.halt_throw_value) do
-        subject.capture { "something1" }
+        subject.capture{ "something1" }
         subject.halt
-        subject.capture { "something2" }
+        subject.capture{ "something2" }
       end
 
       assert_that(subject.sub_results.size).equals(1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: much-result
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Kelly Redding
@@ -9,22 +9,36 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: much-style-guide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: assert
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.18.4
+        version: 2.19.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.18.4
+        version: 2.19.3
 description: API for managing the results of operations.
 email:
 - kelly@kellyredding.com
@@ -36,6 +50,7 @@ files:
 - Gemfile
 - LICENSE
 - README.md
+- grep
 - lib/much-result.rb
 - lib/much-result/aggregate.rb
 - lib/much-result/transaction.rb
@@ -68,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.4
 signing_key: 
 specification_version: 4
 summary: API for managing the results of operations.