to-result 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc48c861de210a05cba164c61710457447f04b60b492ef15791ab7e5c28a3375
-  data.tar.gz: fb5802866e75958e710ec9a0be23584f8f737101ef8afd18c5b212a775539c1c
+  metadata.gz: d9f9dde009ad8e058a1b645888a53f768c8d2571cd91266f77b1017c8aa469ff
+  data.tar.gz: fcbd389f7a3f8d0ddf101cb1064a70a225c039f3cc41c19ca64cac3229469fb9
 SHA512:
-  metadata.gz: 60728e022ce553988082effc1ab86a3260cf399a464bddea06d936e6428bf54f0604a8b86638ee7932526a20d72b3c80bcc491f6d816d6d17bdd93326c11b2ce
-  data.tar.gz: 959d7af9b3eb1367269c6650ca9c9babedd8c3cfd6e36403d3d4f01b750219dc7781cec78e4bc2a4972ce34e230d157dbd17a8bee70b7c9cc24c407fb71f5bc3
+  metadata.gz: '08e53f93d442d8d5570cb03eac07df8865f6cb4c14bf1daf0eb9f0db064553d879473379cffdc2cd3707100a690d2aebd26340b69d8faea087c9eb17251e5c71'
+  data.tar.gz: 435173009f18e28de610c30424070814b4550e4bb13f5359fda42130eb5fc32887c6004cc6c6aa02b7799b29d74f5b3824b782fdf9c235d90ef5fbd4559dbd07

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.1)
+    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

@@ -180,6 +180,13 @@ 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 type of suggestion is appreciated 😁
 
+## Relasing a new version
+
+```
+  gem build to-result
+  gem push to-result-<version>.gem
+```
+
 ## Authors
 
 - [@a-chris](https://www.github.com/a-chris)

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,14 +39,14 @@ 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
         failure = error = e.result
         error = error.failure if error.respond_to?(:failure)
@@ -57,6 +57,6 @@ module ToResultMixin
         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.1'
+  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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: to-result
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Christian Toscano
@@ -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:

data/tests/support/fake_logger.rb

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

data/tests/to_result_test.rb

@@ -1,114 +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 { |e| FakeLogger.log_error(e) }
-      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) { yield Failure(expected) } == Failure(expected)
-  end
-end