rresult 0.1.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a5e5a6db001e80dd33d18496f00c02befb0edce12a780a4dd0e88955e88c551
+  data.tar.gz: c99e0b23767416fad14acab2464639c5f9e9975ebeb81a81aab8128d26d09b41
+SHA512:
+  metadata.gz: 6f8f60e83598d99163750914bc2511d4f0a7685f3a3a1bbd151c094a7c542c7253544c08e1d017faf810ca2dabf3058458626050852c3af3b1d572b8be62892d
+  data.tar.gz: 034e6cfdb48c1def1adaab8ce44b8cc3bd0ed21f85a1ebb9863048bd28d3db97d49e094f861d7c74cb438b0369260f9f5b85239e838fc1c9b4bf7eb7646b8076

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.bundle
+Gemfile.lock
+*.gem
+vendor

data/.rubocop.yml

@@ -0,0 +1,14 @@
+AllCops:
+    NewCops:
+      enable
+    TargetRubyVersion: 3
+
+Layout/IndentationWidth:
+    Width: 4
+Metrics/BlockLength:
+    Exclude:
+      - spec/result_spec.rb
+Style/ExpandPathArguments:
+    Enabled: false
+Style/ParallelAssignment:
+    Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Thomas Villa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+# Result-rb
+
+A ruby port of the `Rust` result-monad `Result`.
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+````ruby
+gem 'rresult'
+`````
+
+## Usage
+
+The Result can be an `Ok`, to wrap successfull values, or an `Err`, to wrap something that went wrong.
+
+An `Err` has a description, this should be a `Symbol`, and a value, which can be any `Object`
+
+### Constructors
+
+Regular class-constructors:
+````ruby
+ok_result = Result::ok(42)
+
+err_result = Result::err(description: :not_the_answer_to_anything, value: 41)
+````
+
+`Object` is monkey-patched to provide convenience-constructors
+````ruby
+ok_result = Ok(42)
+
+err_result = Err(:not_the_answer_to_anything, 41)
+````
+
+### Some inspectors
+
+Check if the `Result` is `Ok` or `Err`
+````ruby
+Ok(42).ok? == true
+Ok(42).is_ok == true
+
+Err(:not_the_answer_to_anything, 41).err? == true
+Err(:not_the_answer_to_anything, 41).is_err == true
+````
+
+Check the wrapped value inside:
+````ruby
+Ok(42).contains? 42 == true
+Ok(42).contains 42  == true
+
+Err(:not_the_answer_to_anything, 41).contains_err?(:not_the_answer_to_anything, 42) == true
+Err(:not_the_answer_to_anything, 41).contains_err(:not_the_answer_to_anything, 42)  == true
+````
+
+### Accessors
+Get the wrapped error elements with `#err_description` and `#err_value`.
+These return `nil` for an `Ok`. 
+````ruby
+Ok(42).err_description                               == nil
+Ok(42).err_value                                     == nil
+Err(:not_the_answer_to_anything, 41).err_description == :not_the_answer_to_anything
+Err(:not_the_answer_to_anything, 41).err_value       == 41
+````
+
+### Unwrappers
+`#unwrap` return the wrapped value of an `Ok`, but raises a `RuntimeError` for an `Err`
+````ruby
+Ok(42).unwrap == 42
+Err(:wrong_answer, 41).unwrap # raises RuntimeError
+````
+
+`#unwrap_err` returns an `Array` with the description and value of an `Err`, but raises a `RuntimeError` for an `Ok`
+````ruby
+Ok(42).unwrap # raises RuntimeError
+Err(:wrong_answer, 41).unwrap_err == [:wrong_answer, 41]
+````
+
+`#unwrap_or` unwraps an `Ok` or returns the provided default if `Err`
+````ruby
+Ok(42).unwrap_or(-1)                               == 42
+Err(:not_the_answer_to_anything, 41).unwrap_or(-1) == -1
+````
+
+`#unwrap_or_else` unwraps an `Ok` or returns the provided default if `Err` as result of the block.
+The block takes the error description and the error value
+````ruby
+Ok(42).unwrap_or_else { |descr, val| val / 2 }                              == 42
+Err(:not_the_answer_to_anything, 41).unwrap_or_else{ |descr, val| val / 2 } == 20
+````
+
+### Map
+`#map` allows to apply a block to the wrapped value, if its `Ok`. It does not touch an `Err`
+````ruby
+Ok(42).map { |val| val * 2 } == Ok(84)
+
+Err(:not_the_answer_to_anything, 41).map { |val| val * 2 } == Err(:not_the_answer_to_anything, 41)
+````
+
+`#map_or` unwraps the `Result` and returns a default value, in case of an `Err`
+````ruby
+Ok(42).map_or(-1) { |val| val * 2 } == 84
+
+Err(:not_the_answer_to_anything, 41).map_or(-1) { |val| val * 2 } == -1
+````
+
+`#map_or_else` unwraps the `Result` like `#map_or`, but take 2 lambda's to specify the mapping of both `Ok` and `Err`
+````ruby
+map     = ->(ok_val)         { ok_val * 2 }
+or_else = ->(_desc, err_val) { err_val / 2 }
+
+Ok(42).map_or_else(map: map, or_else: or_else) == 84
+Err(:not_the_answer_to_anything, 41).map_or_else(map: map, or_else: or_else) == 20
+````
+
+`#map_err` maps an `Err` with a provided block. That block should return an `Array` with the new description and value
+````ruby
+Ok(42).map_err { |descr, err_val| val * 2 } == Ok(84)
+
+Err(:not_the_answer_to_anything, 41).map { |val| val * 2 } == Err(:not_the_answer_to_anything, 41)
+````
+
+### Logical AND combinator
+
+`#and` replaces the value of the `Result` by that of that argument, only if the `Result` is an `Ok`
+````ruby
+some_ok_res = Ok(-1)
+some_err_res = Err(:mistake, 'you did something wrong')
+
+Ok(42).and(some_ok_res)                                == some_ok_res
+Ok(42).and(some_err_res)                               == some_ok_res
+Err(:not_the_answer_to_anything, 41).and(some_ok_res)  == Err(:not_the_answer_to_anything, 41)
+Err(:not_the_answer_to_anything, 41).and(some_err_res) == Err(:not_the_answer_to_anything, 41)
+````
+
+`#and_then` applies a logical AND with the result of a block
+````ruby
+Ok(42).and_then { |val| Ok(val * 2) }).to be == Ok(84)
+Ok(42).and_then { |val| Err(:wrong_answer, 41) } == Err(:wrong_answer, 41)
+````
+
+### Logical OR combinator
+
+`#or` replaces the value of the `Result` by that of that argument, only if the `Result` is an `Err`
+````ruby
+some_ok_res = Ok(-1)
+some_err_res = Err(:mistake, 'you did something wrong')
+
+Ok(42).or(some_ok_res)                                == Ok(42)
+Ok(42).and(some_err_res)                              == Ok(42)
+Err(:not_the_answer_to_anything, 41).or(some_ok_res)  == some_ok_res
+Err(:not_the_answer_to_anything, 41).or(some_err_res) == some_err_res
+````
+
+`#or_else` applies a logical OR with the result of a block. The block provides takes the description and value of the `Err`
+````ruby
+Err(:wrong_answer, 41).or_else { |descr, val| Ok(val / 2) }).to be      == Ok(20)
+Err(:wrong_answer, 41).or_else { |descr, val| Err(:not_corrected, -1) } == Err(:not_corrected, -1)
+````

data/lib/result/core_ext/object.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Convenience-constructors for `Result`
+class Object
+    # rubocop:disable Naming/MethodName
+    def Ok(value)
+        Result.ok(value)
+    end
+
+    def Err(description, value)
+        Result.err(description: description, value: value)
+    end
+    # rubocop:enable Naming/MethodName
+end

data/lib/result/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Result
+    VERSION = '0.1.8'
+end

data/lib/rresult.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Result can hold a success value in an `Ok` or and error in an `Err`
+class Result
+    attr_reader :ok, :err_description, :err_value
+
+    def initialize(ok_val, err_description, err_value, type)
+        @ok, @err_description, @err_value, @type = ok_val, err_description, err_value, type
+    end
+
+    def self.ok(value)
+        new(value, nil, nil, :ok)
+    end
+
+    def self.err(description:, value:)
+        raise ArgumentError, 'The error description should be a symbol' unless description.is_a? Symbol
+
+        new(nil, description, value, :err)
+    end
+
+    def ok?
+        @type == :ok
+    end
+
+    def err?
+        @type == :err
+    end
+
+    def contains?(val)
+        @ok == val
+    end
+
+    def contains_err?(description, value)
+        @err_description == description && @err_value == value
+    end
+
+    def map
+        return self if err?
+
+        Result.ok(yield @ok)
+    end
+
+    def map_or(val)
+        err? ? val : yield(@ok)
+    end
+
+    def map_or_else(map:, or_else:)
+        err? ? or_else.call(@err_description, @err_value) : map.call(@ok)
+    end
+
+    def map_err
+        return self if ok?
+
+        descr, val = yield @err_description, @err_value
+        Result.err(description: descr, value: val)
+    end
+
+    def and(other_res)
+        err? ? self : other_res
+    end
+
+    def and_then
+        return self if err?
+
+        new_res = yield @ok
+        raise "The provided block should return a Result, not a #{new_res.class}" unless new_res.is_a? Result
+
+        self.and new_res
+    end
+
+    def or(other_res)
+        ok? ? self : other_res
+    end
+
+    def or_else
+        return self if ok?
+
+        new_res = yield @err_description, @err_value
+        raise "The provided block should return a Result, not a #{new_res.class}" unless new_res.is_a? Result
+
+        self.or new_res
+    end
+
+    def unwrap_or(ok_value)
+        err? ? ok_value : @ok
+    end
+
+    def unwrap_or_else
+        err? ? yield(@err_description, @err_value) : @ok
+    end
+
+    def unwrap
+        raise unwrap_runtime_error_msg if err?
+
+        @ok
+    end
+
+    def unwrap_err
+        raise unwrap_err_runtime_error_msg if ok?
+
+        [@err_description, @err_value]
+    end
+
+    def ==(other)
+        @ok == other.ok && @err_description == other.err_description && @err_value == err_value
+    end
+
+    def ===(other)
+        self == other
+    end
+
+    def inspect
+        ok? ? "Result::Ok(#{@ok.inspect})" : "Result::Err(#{@err_description.inspect}, #{@err_value.inspect})"
+    end
+
+    private
+
+    def unwrap_runtime_error_msg
+        "\nCan't unwrap a Result::Err\n    #{@err_description}\n    #{@err_value}"
+    end
+
+    def unwrap_err_runtime_error_msg
+        "\nCan't unwrap_err a Result::Ok\n    #{@ok}"
+    end
+
+    private_class_method :new
+    alias is_ok ok?
+    alias is_err err?
+    alias contains contains?
+    alias contains_err contains_err?
+end
+
+require_relative './result/core_ext/object'

data/result.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'result/version'
+
+Gem::Specification.new do |s|
+    s.name        = 'rresult'
+    s.version     = Result::VERSION
+    s.authors     = ['Thomas Villa']
+    s.email       = ['thomvil87@gmail.com']
+
+    s.summary     = 'A ruby port of the Rust Result enum.'
+    s.description = "A ruby port of the Rust Result enum. 🦀\n Documentation will be added later. For now visit https://gitlab/thomvil/result-rb for usage"
+    s.homepage    = 'http://gitlab.com/thomvil/result-rb'
+    s.license     = 'MIT'
+
+    s.files = `git ls-files -z`.split("\x0")
+                               .reject { |f| f.match?(%r{^(test|spec|features)/}) || f.match?(/\.code-workspace$/) }
+
+    s.require_paths         = ['lib']
+    s.required_ruby_version = '>= 3.0'
+
+    s.add_development_dependency 'rspec', '~> 3.10'
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: rresult
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+platform: ruby
+authors:
+- Thomas Villa
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: "A ruby port of the Rust Result enum. \U0001F980\n Documentation will
+  be added later. For now visit https://gitlab/thomvil/result-rb for usage"
+email:
+- thomvil87@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- lib/result/core_ext/object.rb
+- lib/result/version.rb
+- lib/rresult.rb
+- result.gemspec
+homepage: http://gitlab.com/thomvil/result-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.4
+signing_key:
+specification_version: 4
+summary: A ruby port of the Rust Result enum.
+test_files: []