to-result 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc8202a00d4cc8938cac602f09b0a9b0694a29421bedb0c71be82f94fad66e89
-  data.tar.gz: 783334b0487c880174639c699eb61fc6eacd695086a5c5b9b531947bd1645b30
+  metadata.gz: d9f9dde009ad8e058a1b645888a53f768c8d2571cd91266f77b1017c8aa469ff
+  data.tar.gz: fcbd389f7a3f8d0ddf101cb1064a70a225c039f3cc41c19ca64cac3229469fb9
 SHA512:
-  metadata.gz: 4e2b40217e547f2cabbcc84847f1f257676863997c088f4e2c43416a608fd804b07bf7586e95d6ab60b8c70fa501b6cd297deb7d9ad7a86f0acade0977ef5f64
-  data.tar.gz: feceedd4425f782ee47637da08a69fbef6f54b226a5bd104e6a8f22ea219a9b4be1fd30ffac56e88df0ec1aa2212f4c2ea2994b81f51155f8d1dae8ff29fb41b
+  metadata.gz: '08e53f93d442d8d5570cb03eac07df8865f6cb4c14bf1daf0eb9f0db064553d879473379cffdc2cd3707100a690d2aebd26340b69d8faea087c9eb17251e5c71'
+  data.tar.gz: 435173009f18e28de610c30424070814b4550e4bb13f5359fda42130eb5fc32887c6004cc6c6aa02b7799b29d74f5b3824b782fdf9c235d90ef5fbd4559dbd07

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.1.1](https://github.com/a-chris/to-result/tree/0.1.1) (2023-08-16)
+
+HOTFIXES:
+
+- Always pass the error to the `on_error` callable object instead of mixed `error/Failure(error)`
+
 ## [0.1.0](https://github.com/a-chris/to-result/tree/0.1.0) (2022-10-28)
 
 - Explicit requires `dry-monads` >= 1.x, just for convenience

data/Gemfile

@@ -5,10 +5,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in pulsarcli.gemspec
 gemspec
 
-gem 'dry-monads', '~> 1.5'
+gem 'dry-monads', '~> 1.6'
 
 gem 'byebug', '~> 11.1'
 
-gem 'minitest', '~> 5.16'
-
-gem 'mocha', '~> 1.15'
+gem 'rspec'

data/Gemfile.lock

@@ -1,33 +1,44 @@
 PATH
   remote: .
   specs:
-    to-result (0.1.0)
+    to-result (0.2.0)
       dry-monads (~> 1.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
     byebug (11.1.3)
-    concurrent-ruby (1.1.10)
-    dry-core (0.9.1)
+    concurrent-ruby (1.2.2)
+    diff-lcs (1.5.0)
+    dry-core (1.0.1)
       concurrent-ruby (~> 1.0)
       zeitwerk (~> 2.6)
-    dry-monads (1.5.0)
+    dry-monads (1.6.0)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.9, >= 0.9)
+      dry-core (~> 1.0, < 2)
       zeitwerk (~> 2.6)
-    minitest (5.16.3)
-    mocha (1.15.0)
-    zeitwerk (2.6.1)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    zeitwerk (2.6.11)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   byebug (~> 11.1)
-  dry-monads (~> 1.5)
-  minitest (~> 5.16)
-  mocha (~> 1.15)
+  dry-monads (~> 1.6)
+  rspec
   to-result!
 
 BUNDLED WITH

data/README.md

@@ -1,7 +1,7 @@
 
 # ToResult
 
-ToResult is a wrapper built over `dry-monads` to make the `Do Notation`, `Result` and `Try` concepts more handy and consistent to use, in particular to implement the **Railway Pattern**.
+ToResult is a wrapper built over `dry-monads` to make the `Do Notation`, `Result` and `Try` concepts more handy and consistent to use, especially to implement the **Railway Pattern**.
 
 ## Why I created ToResult
 
@@ -120,7 +120,7 @@ class MyClass
 end
 ```
 
-now you can always use `ToResult` all the time you wanted to use `Success`, `Failure` or `Try` but with a more convenient interface and consistent behaviour.
+now you can always use `ToResult` all the time you wanted to use `Try` or return `Success/Failure` but with a more convenient interface and consistent behaviour, my goal is to have a solution that can be used for every use-case.
 
 Look at this:
 
@@ -144,6 +144,30 @@ ToResult(only: [ArgumentError]) { yield Failure(YourCustomError.new('error code'
 # raises YourCustomError('error code')
 ```
 
+## Local and global callback on errors
+to-result gives you the possibility to define a callback to be called when an error is raised inside the `ToResult` block, this is a handy place to log errors.
+
+You can define a global callback, usually defined into an initializer:
+
+```ruby
+# initializers/to_result.rb
+
+ToResultMixin.configure do |c|
+  c.on_error = Proc.new { |e| Logger.log_error(e) }
+end
+```
+
+or a local callback:
+
+```ruby
+ToResult(on_error: proc { |e| Logger.log_error(e) }) do
+  yield Failure(StandardError.new('error code'))
+end
+```
+
+you can even use both at the same time but keep in mind that **local callback overrides the global one**.
+
+
 ## Changelog
 
 [Changelog](CHANGELOG.md)
@@ -154,7 +178,14 @@ I'm already planning to implement some useful features:
 - [x] configurable error logging when an exception is catched inside `DoResult`
 e.g. sending the log to Airbrake or whathever service you are using
 - [x] transform/process the catched error => this can be handled with `alt_map` or other methods already available in `dry-monads`
-- [ ] any other suggestion would be appreciated 😁
+- [ ] any type of suggestion is appreciated 😁
+
+## Relasing a new version
+
+```
+  gem build to-result
+  gem push to-result-<version>.gem
+```
 
 ## Authors
 

data/lib/to-result.rb

@@ -7,7 +7,7 @@ module ToResultMixin
     attr_accessor :on_error
 
     def on_error=(value)
-      raise TypeError.new('on_error is expected to be a callable object') unless value.respond_to?(:call)
+      raise TypeError, 'on_error is expected to be a callable object' unless value.respond_to?(:call)
 
       @on_error = value
     end
@@ -39,23 +39,24 @@ module ToResultMixin
   # @return [Success]
   # @return [Failure]
   #
-  def ToResult(only: [StandardError], **args, &f)
+  def ToResult(only: [StandardError], **args, &block)
     # on_error included in args so we can distinguish when it's passed but it's nil
     # from when it's not passed at all
     on_error ||= args.key?(:on_error) ? args[:on_error] : @@configuration.on_error
 
-    f_wrapper =
-      Proc.new do
-        f.call
+    block_wrapper =
+      proc do
+        block.call
       rescue Dry::Monads::Do::Halt => e
-        error = e.result
+        failure = error = e.result
+        error = error.failure if error.respond_to?(:failure)
         on_error.call(error) if on_error.respond_to?(:call)
-        return error
+        return failure
       rescue *only => e
         on_error.call(e) if on_error.respond_to?(:call)
         raise e
       end
 
-    Try.run(only, f_wrapper).to_result
+    Try.run(only, block_wrapper).to_result
   end
 end

data/spec/support/fake_object.rb

@@ -0,0 +1,15 @@
+class FakeObject
+  extend ToResultMixin
+
+  def self.log_error(e)
+    e
+  end
+
+  def self.log_error_copy(e)
+    e
+  end
+
+  def self.raise_do_halt_error(failure, on_error: nil)
+    ToResult(on_error: on_error) { yield failure }
+  end
+end

data/spec/to_result_spec.rb

@@ -0,0 +1,116 @@
+require 'byebug'
+
+require './lib/to-result'
+require './spec/support/fake_object'
+
+
+RSpec.describe ToResultMixin do
+  include ToResultMixin
+
+  let(:value) { 'hello world!' }
+
+  before do
+    # reset the configuration before each test
+    ToResultMixin.configure { |c| c = {} }
+  end
+
+  describe 'result handling' do
+    it 'returns a Success with the value of the block' do
+      expect(ToResult { value }).to eq(Success(value))
+    end
+
+    it 'returns a Success without the Success of the block' do
+      expected = Success(value)
+      expect(ToResult { expected }).to eq(Success(expected))
+    end
+
+    it 'returns a Failure with the exception raised by the block' do
+      expected = StandardError.new(value)
+      expect(ToResult { raise expected }).to eq(Failure(expected))
+    end
+
+    it 'returns a Failure if the error class is included in `only`' do
+      expected = ArgumentError.new(value)
+      expect(ToResult(only: [ArgumentError]) { raise expected }).to eq(Failure(expected))
+    end
+
+    it 'raises an error if the error class is not included in `only`' do
+      expected = NameError.new(value)
+      expect { ToResult(only: [ArgumentError]) { raise expected } }.to raise_error(NameError)
+    end
+
+    it 'returns Failure if the block raises a Dry::Monads::Do::Halt error' do
+      expected = Dry::Monads::Failure(StandardError.new(value))
+      # it equals to ToResult { yield expected }
+      expect(FakeObject.raise_do_halt_error(expected)).to eq(expected)
+    end
+  end
+
+  describe 'on_error' do
+    it 'passes the unwrapped error to on_error' do
+      local_on_error = proc { |e| FakeObject.log_error(e) }
+
+      expected  = StandardError.new(value)
+      failure   = Failure(expected)
+      expect(FakeObject).to receive(:log_error).and_return(expected).once
+      # it equals to ToResult { yield expected }
+      expect(FakeObject.raise_do_halt_error(failure, on_error: local_on_error)).to eq(Dry::Monads::Failure.new(expected))
+    end
+
+    context 'when gloval callback is not defiend' do
+      it 'uses the local on_error' do
+        local_on_error = proc { |e| FakeObject.log_error(e) }
+
+        expected = StandardError.new(value)
+        expect(FakeObject).to receive(:log_error).and_return(expected).once
+        expect(ToResult(on_error: local_on_error) { raise expected }).to eq(Failure(expected))
+      end
+
+      it 'does not raise error if local on_error is not a proc' do
+        local_on_error = 'not a proc'
+
+        expected = StandardError.new(value)
+        FakeObject.methods(false).each { |m| expect(FakeObject).to receive(m).never }
+        expect(ToResult(on_error: local_on_error) { raise expected }).to eq(Failure(expected))
+      end
+    end
+
+    context 'when global callback is invalid' do
+      it 'raises an error' do
+        expect do
+          ToResultMixin.configure { |c| c.on_error = 'invalid value, should be a proc' }
+        end.to raise_error(TypeError)
+      end
+    end
+
+    context 'when global callback if valid and defined globally' do
+      before do
+        ToResultMixin.configure do |c|
+          c.on_error = proc { |e| FakeObject.log_error(e) }
+        end
+      end
+
+      it 'calls the global callback' do
+        expected = StandardError.new(value)
+        expect(FakeObject).to receive(:log_error).with(expected).once
+        expect(ToResult { raise expected }).to eq(Failure(expected))
+      end
+
+      it 'uses local on_error over the global one' do
+        local_on_error = Proc.new { |e| FakeObject.log_error_copy(e) }
+
+        expected = StandardError.new(value)
+        expect(FakeObject).to receive(:log_error_copy).with(expected).once
+        expect(ToResult(on_error: local_on_error) { raise expected }).to eq(Failure(expected))
+      end
+
+      it 'uses local on_error over the global one even if nil' do
+        local_on_error = nil
+
+        expected = StandardError.new(value)
+        FakeObject.methods(false).each { |m| expect(FakeObject).to receive(m).never }
+        expect(ToResult(on_error: local_on_error) { raise expected }).to eq(Failure(expected))
+      end
+    end
+  end
+end

data/to-result.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name        = 'to-result'
-  s.version     = '0.1.0'
+  s.version     = '0.2.0'
   s.summary     = 'A wrapper over dry-monads to offer a handy and consistent way to implement the Railway pattern.'
   s.description = 'A wrapper over dry-monads to offer a handy and consistent way to implement the Railway pattern.'
   s.authors     = ['Christian Toscano']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: to-result
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Christian Toscano
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-27 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -38,8 +38,8 @@ files:
 - README.md
 - bin/console
 - lib/to-result.rb
-- tests/support/fake_logger.rb
-- tests/to_result_test.rb
+- spec/support/fake_object.rb
+- spec/to_result_spec.rb
 - to-result.gemspec
 homepage: https://github.com/a-chris/to-result
 licenses:
@@ -60,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A wrapper over dry-monads to offer a handy and consistent way to implement

data/tests/support/fake_logger.rb

@@ -1,9 +0,0 @@
-class FakeLogger
-  def self.log_error
-    true
-  end
-
-  def self.return_error(e)
-    e
-  end
-end

data/tests/to_result_test.rb

@@ -1,113 +0,0 @@
-require 'minitest/autorun'
-require 'mocha/minitest'
-require 'byebug'
-
-require './lib/to-result'
-require './tests/support/fake_logger'
-
-class ToResultTest < Minitest::Test
-  include ToResultMixin
-
-  def setup
-    super
-    @value = 'hello world!'
-  end
-
-  def teardown
-    super
-
-    # reset the configuration after each test
-    ToResultMixin.configure { |c| c = {} }
-  end
-
-  def test_string
-    assert ToResult { @value } == Success(@value)
-  end
-
-  def test_success
-    expected = Success(@value)
-    assert ToResult { expected } == Success(expected)
-  end
-
-  def test_exception
-    expected = StandardError.new(@value)
-    assert ToResult { raise expected } == Failure(expected)
-  end
-
-  def test_exception_included_in_exceptions_list
-    expected = ArgumentError.new(@value)
-    assert ToResult(only: [ArgumentError]) { raise expected } == Failure(expected)
-  end
-
-  def test_exception_not_included_in_exceptions_list
-    expected = NameError.new(@value)
-    assert_raises(NameError) { ToResult(only: [ArgumentError]) { raise expected } }
-  end
-
-  def test_yield_failure
-    expected = Failure(@value)
-    # this will raise a Dry::Monads::Do::Halt exception
-    assert ToResult { yield expected } == expected
-  end
-
-  def test_yield_failure_exception
-    expected = Failure(StandardError.new(@value))
-    # this will raise a Dry::Monads::Do::Halt exception
-    assert ToResult { yield expected } == expected
-  end
-
-  def test_invalid_global_on_error
-    assert_raises(TypeError) do
-      ToResultMixin.configure { |c| c.on_error = 'invalid value' }
-    end
-  end
-
-  def setup_global_on_error
-    # creating a clean room just for testing purpose
-    clean_room = Class.new(Object)
-    clean_room.new.instance_eval do
-      ToResultMixin.configure do |c|
-        c.on_error = Proc.new { FakeLogger.log_error }
-      end
-    end
-  end
-
-  def test_global_on_error
-    setup_global_on_error
-
-    FakeLogger.expects(:log_error).once
-
-    expected = StandardError.new(@value)
-    assert ToResult { raise expected } == Failure(expected)
-  end
-
-  def test_local_on_error_overrides_global
-    setup_global_on_error
-
-    FakeLogger.expects(:log_error).once
-
-    local_on_error = Proc.new { FakeLogger.log_error }
-
-    expected = StandardError.new(@value)
-    assert ToResult(on_error: local_on_error) { raise expected } == Failure(expected)
-  end
-
-  def test_local_on_error_overrides_global_nil
-    setup_global_on_error
-
-    FakeLogger.expects(:log_error).never
-
-    local_on_error = nil
-
-    expected = StandardError.new(@value)
-    assert ToResult(on_error: local_on_error) { raise expected } == Failure(expected)
-  end
-
-  def test_local_on_error_without_global
-    local_on_error = Proc.new { |e| FakeLogger.return_error(e) }
-
-    expected = StandardError.new(@value)
-    FakeLogger.expects(:return_error).with(expected).returns(expected).once
-    assert ToResult(on_error: local_on_error) { raise expected } == Failure(expected)
-  end
-end