safe_operation 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1e94fff35d4584131e4618984db17237d7e0eb20
-  data.tar.gz: 5990172463731f5ea965977ab30ebca21a7c5fe5
+SHA256:
+  metadata.gz: b91d97c00cb10cf98d6811a622637447ebb610da081a40e82a470b4a14d14a56
+  data.tar.gz: 715f3660b7f47295f32c3c221b48f2bbbb9bb5787a62190f8430e9e8c9d85b31
 SHA512:
-  metadata.gz: b386772b2152fd9699f92fd7050b6da0086e503abc8082d309739302fd611eb0f9312169920cf4bae598a1c9f26385a1ff94f3439fe151ebc8aae5821ee2aaee
-  data.tar.gz: aa6ddc9cb1ed18e8621476d42c2806d87775621bd46fe91e3ca9564e92e10e7a2634fd82b8b1678e6779643459545db3c17bbf6ac072b8375fdb2e98a2fd9c1e
+  metadata.gz: 3c1304db8d9cbf0a022199fdc6dfb2d52984b01c0a76dd5cceefd5307fb8ea6ef28a6cc084058ef45c9dce706c4faf611ba6f7f7e76ca159bec744c6899b98b5
+  data.tar.gz: b31daab86df7e66d43283eb8c36523ec8b990413f7e2c135b4d8fcac93bfcb2ef3cffb251621506b894ea7fbd2c1bc2270597b9be68feaa8ab5efc244f0d9969

data/.rspec

@@ -1 +1,2 @@
 --color
+--format documentation

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 2.0.0
+
+- Drop support for v1.0.0
+- v2.0.0 redesigned the API of SafeOperation:
+
+  SafeOperation.run
+
+  SafeOperation#value_or
+  SafeOperation#value_or_else
+  SafeOperation#and_then
+  SafeOperation#or_else
+
 ## 1.0.0
 
 First implementation ([#1][pr1]) - 2017.07.09

data/README.md

@@ -1,20 +1,9 @@
 # SafeOperation
 
-Write safer code with SafeOperation.
-
-```ruby
-any_operation_may_fail = ->{ User.find(1) }
+[![Gem Version](https://badge.fury.io/rb/safe_operation.svg)](https://rubygems.org/gems/safe_operation)
+[![Build Status](https://travis-ci.org/JuanitoFatas/safe_operation.svg?branch=master)](https://travis-ci.org/JuanitoFatas/safe_operation)
 
-operation = SafeOperation.either(any_operation_may_fail) do
-  # MUST handle the failure here
-end
-
-# know if operation succeeded
-operation.success?
-
-# get the result of the performed operation
-operation.result
-```
+Write safer code with SafeOperation.
 
 ## Installation
 
@@ -34,46 +23,68 @@ Or install it yourself as:
 
 ## Usage
 
+No monkey patch.
+
 ```ruby
-class User
-  ActiveRecordRecordNotFound = Class.new(StandardError)
+class RecordNotFound < StandardError; end
+class User def self.find(id); new; end; end;
+class Guest; end
+class Admin; def initialize(user); end; end
+class SuperAdmin; def initialize(admin); end; end
+
+operation = SafeOperation.run do
+  User.find(1)
+end
 
-  def self.find(id)
-    (id == 1) ? new : raise(ActiveRecordRecordNotFound)
-  end
+# Know if operation succeeded
+operation.success?
 
-  def self.find_by(*); end
-end
+# Get the value of the performed operation
+operation.value
 
-class Guest
+# Common patterns, reloaded
+SafeOperation.run { User.find(1) }.value_or(Guest.new)
+
+# Handling exceptions
+SafeOperation.run { raise(RecordNotFound) }.value_or_else do |exception|
+  if exception.is_a?(RecordNotFound)
+    Guest.new
+  else
+    # logging, re-raise, etc.
+  end
 end
 
-SafeOperation.either(->{ User.find(1) })
-# => raises an SafeOperation::NoFailureHandler error
+# Apply on first operation
+operation = SafeOperation.
+  run { User.find(1) }.
+  and_then { |user| Admin.new(user) }
 
-SafeOperation.either(->{ User.find(1) }) do
-  Guest.new
-end
-# => returns a SafeOperation::Success object with User
-# => #<SafeOperation::Success:0x007fbc8d8c5ae0 @success=#<User:0x007fbc8d8c5b08>>
+operation.value # #<Admin ...>
 
-SafeOperation.either(->{ User.find(2) }) do
-  Guest.new
-end
-# => rescue ActiveRecordRecordNotFound, returns a SafeOperation::Failure object with Guest
-# #<SafeOperation::Failure:0x007fbc8dbb71e0 @failure=#<Guest:0x007fbc8dbb7208>>
+# Chainable
+operation = SafeOperation.
+  run { User.find(1) }.
+  and_then { |user| Admin.new(user) }.
+  and_then { |admin| SuperAdmin.new(admin) }
 
-SafeOperation.either(->{ User.find_by(id: 42) }) do
-  Guest.new
-end
-# => returns a SafeOperation::Failure object with Guest
-# #<SafeOperation::Failure:0x007fbc8dbb71e0 @failure=#<Guest:0x007fbc8dbb7208>>
+operation.value # #<SuperAdmin ...>
+
+# Add or_else to handle failed operation
+operation = SafeOperation.
+  run { raise(RecordNotFound) }.
+  and_then { |user| Admin.new(user) }.
+  or_else { Guest.new }
+
+operation.success? # => false
+operation.value # => #<Guest ...>
 ```
 
+See test suite for more examples.
+
 ## Contributing
 
 This project follows the [Moya Contributors Guidelines][moya].
-TLDR: means we give out push access easily and often.
+TLDR: means we give out commit access easily and often.
 
 [moya]: https://github.com/Moya/contributors
 

data/lib/safe_operation/failure.rb

@@ -1,18 +1,15 @@
-module SafeOperation
+class SafeOperation
   class Failure
     def initialize(failure)
       @failure = failure
     end
 
-    def result
-      failure
+    def value
+      @failure
     end
 
     def success?
       false
     end
-
-    private
-    attr_reader :failure
   end
 end

data/lib/safe_operation/success.rb

@@ -1,18 +1,15 @@
-module SafeOperation
+class SafeOperation
   class Success
     def initialize(success)
       @success = success
     end
 
-    def result
-      success
+    def value
+      @success
     end
 
     def success?
       true
     end
-
-    private
-    attr_reader :success
   end
 end

data/lib/safe_operation/version.rb

@@ -1,3 +1,3 @@
-module SafeOperation
-  VERSION = "1.0.0"
+class SafeOperation
+  VERSION = "2.0.0"
 end

data/lib/safe_operation.rb

@@ -1,24 +1,66 @@
 # frozen_string_literal: true
+require "forwardable"
 
 require_relative "safe_operation/version"
 require_relative "safe_operation/success"
 require_relative "safe_operation/failure"
 
-module SafeOperation
-  NoFailureHandler = Class.new NotImplementedError
+class SafeOperation
+  extend Forwardable
 
-  def self.either(maybe_block)
-    raise NoFailureHandler if !block_given?
+  class << self
+    protected(:new)
 
-    if maybe = maybe_block.call
-      Success.new maybe
+    def run
+      success(yield)
+    rescue StandardError => exception
+      failure(exception)
+    end
+
+    def success(value)
+      new(success: value)
+    end
+
+    def failure(value)
+      new(failure: value)
+    end
+  end
+
+  def_delegators :@result, :success?, :value
+
+  def initialize(success: nil, failure: nil)
+    @result = success ? Success.new(success) : Failure.new(failure)
+  end
+
+  def value_or(fallback_value)
+    if success?
+      value
     else
-      Failure.new yield
+      fallback_value
     end
-  rescue StandardError
-    Failure.new yield
   end
 
-  NO_FAILURE_HANDLER_MESSAGE = "Please pass in a block to handle the failure 😅"
-  private_constant :NO_FAILURE_HANDLER_MESSAGE
+  def value_or_else(&fallback_block)
+    if success?
+      value
+    else
+      fallback_block.call(value)
+    end
+  end
+
+  def and_then(&block)
+    if success?
+      self.class.success(block.call(value))
+    else
+      self
+    end
+  end
+
+  def or_else(&block)
+    if success?
+      self
+    else
+      self.class.failure(block.call(value))
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: safe_operation
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Juanito Fatas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-09 00:00:00.000000000 Z
+date: 2019-04-06 00:00:00.000000000 Z
 dependencies: []
 description: Write safer code with SafeOperation.
 email:
@@ -52,8 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Write safer code with SafeOperation.