sorbet-result 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79770af90bc94993111e0e11b8d4dfcf7660d19e878a1f55642e607fcc6db579
-  data.tar.gz: eb5c66753067b295ed7750aec1a0de64630c9f0fe5d5f5e3f20b5f3d66b33de2
+  metadata.gz: 94d11199cfc745364d1c1163b60f8a1602699f136f5c6522dfa7a81f64d6f8b1
+  data.tar.gz: b867a4439f5a0e5f8335848c42599563149b950a42e54495cbbe1c38b8d4c60d
 SHA512:
-  metadata.gz: 75311c18528aa78e426b0f497d4a5d6bb69dc859811b1bfe27201df062422243f2ba091c232141baa13d8a5092e10dc52d11e6e3654b7bc47979e0d88a306e63
-  data.tar.gz: 0e76944518d89dfa80d5025590ccb4c6867977edcf4ae626f155a5b8ce8cc1e52b1a8d61186e9e24c9d0d13af9fca51612374a178ef91ebe6ef672bd9b59efd1
+  metadata.gz: 73a6915ad1ca43e1bc729f4be2d0b7bec3c5dcacce072e96074b0d8ce98b9033ffcbdc254b743e10e5156bac08d418d912f45ea50f83c571774c3419f449f6e9
+  data.tar.gz: 18d8c8f3921cb4d60fde19d8270281f67de8d39aecb57830b8eb6c79e96fdfe5ac18b3ca056e7c265ede393ba91e180d078b9b0aa9396ff4a92f917b26d8819f

data/.ruby-version

@@ -1 +1 @@
-3.2.2
+3.3.0

data/.standard.yml

@@ -0,0 +1,6 @@
+parallel: true
+ruby_version: 3.0
+ignore:
+  - 'vendor/**/*'
+plugins:
+  - standard-sorbet

data/.tool-versions

@@ -1 +1 @@
-ruby 3.2.2
+ruby 3.3.0

data/CHANGELOG.md

@@ -6,6 +6,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0] - 2024-02-21
+
+### Added
+
+- Add minitest assertions for Results
+
+### Changed
+
+- Switched to Standard over using Rubocop directly
+
 ## [1.0.0] - 2023-06-20
 
 ### Removed

data/Gemfile

@@ -7,10 +7,8 @@ gemspec
 
 group :development do
   gem "rake"
-  gem "rubocop"
-  gem "rubocop-minitest"
-  gem "rubocop-rake"
-  gem "rubocop-sorbet"
+  gem "standard"
+  gem "standard-sorbet"
   gem "sorbet"
   gem "spoom"
   gem "tapioca", require: false

data/Gemfile.lock

@@ -1,107 +1,127 @@
 PATH
   remote: .
   specs:
-    sorbet-result (1.0.0)
+    sorbet-result (1.1.0)
       sorbet-runtime (~> 0.5)
-      zeitwerk (~> 2.6)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    debug (1.8.0)
-      irb (>= 1.5.0)
-      reline (>= 0.3.1)
-    diff-lcs (1.5.0)
-    io-console (0.6.0)
-    irb (1.7.0)
-      reline (>= 0.3.0)
-    json (2.6.3)
-    minitest (5.18.1)
+    debug (1.9.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    erubi (1.12.0)
+    io-console (0.7.2)
+    irb (1.11.2)
+      rdoc
+      reline (>= 0.4.2)
+    json (2.7.1)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    minitest (5.22.2)
     netrc (0.11.0)
-    parallel (1.23.0)
-    parser (3.2.2.3)
+    parallel (1.24.0)
+    parser (3.3.0.5)
       ast (~> 2.4.1)
       racc
-    racc (1.7.1)
+    prettier_print (1.2.1)
+    prism (0.24.0)
+    psych (5.1.2)
+      stringio
+    racc (1.7.3)
     rainbow (3.1.1)
-    rake (13.0.6)
-    rbi (0.0.16)
-      ast
-      parser (>= 2.6.4.0)
+    rake (13.1.0)
+    rbi (0.1.9)
+      prism (>= 0.18.0, < 0.25)
       sorbet-runtime (>= 0.5.9204)
-      unparser
-    regexp_parser (2.8.1)
-    reline (0.3.5)
+    rdoc (6.6.2)
+      psych (>= 4.0.0)
+    regexp_parser (2.9.0)
+    reline (0.4.2)
       io-console (~> 0.5)
-    rexml (3.2.5)
-    rubocop (1.52.1)
+    rexml (3.2.6)
+    rubocop (1.60.2)
       json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.2.2.3)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.28.0, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.29.0)
+    rubocop-ast (1.30.0)
       parser (>= 3.2.1.0)
-    rubocop-minitest (0.31.0)
-      rubocop (>= 1.39, < 2.0)
-    rubocop-rake (0.6.0)
-      rubocop (~> 1.0)
-    rubocop-sorbet (0.7.0)
+    rubocop-performance (1.20.2)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+    rubocop-sorbet (0.7.7)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
-    sorbet (0.5.10880)
-      sorbet-static (= 0.5.10880)
-    sorbet-runtime (0.5.10880)
-    sorbet-static (0.5.10880-universal-darwin-22)
-    sorbet-static (0.5.10880-x86_64-linux)
-    sorbet-static-and-runtime (0.5.10880)
-      sorbet (= 0.5.10880)
-      sorbet-runtime (= 0.5.10880)
-    spoom (1.2.1)
-      sorbet (>= 0.5.10187)
-      sorbet-runtime (>= 0.5.9204)
+    sorbet (0.5.11262)
+      sorbet-static (= 0.5.11262)
+    sorbet-runtime (0.5.11262)
+    sorbet-static (0.5.11262-universal-darwin)
+    sorbet-static (0.5.11262-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11262)
+      sorbet (= 0.5.11262)
+      sorbet-runtime (= 0.5.11262)
+    spoom (1.2.4)
+      erubi (>= 1.10.0)
+      sorbet-static-and-runtime (>= 0.5.10187)
+      syntax_tree (>= 6.1.1)
       thor (>= 0.19.2)
-    tapioca (0.11.6)
+    standard (1.34.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.60)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.3)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.3.1)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.20.2)
+    standard-sorbet (0.0.2)
+      lint_roller (~> 1.1)
+      rubocop-sorbet (~> 0.7.0)
+    stringio (3.1.0)
+    syntax_tree (6.2.0)
+      prettier_print (>= 1.2.0)
+    tapioca (0.12.0)
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
       parallel (>= 1.21.0)
-      rbi (~> 0.0.0, >= 0.0.16)
-      sorbet-static-and-runtime (>= 0.5.10187)
+      rbi (>= 0.1.4, < 0.2)
+      sorbet-static-and-runtime (>= 0.5.10820)
       spoom (~> 1.2.0, >= 1.2.0)
       thor (>= 1.2.0)
       yard-sorbet
-    thor (1.2.2)
-    unicode-display_width (2.4.2)
-    unparser (0.6.8)
-      diff-lcs (~> 1.3)
-      parser (>= 3.2.0)
+    thor (1.3.0)
+    unicode-display_width (2.5.0)
     yard (0.9.34)
     yard-sorbet (0.8.1)
       sorbet-runtime (>= 0.5)
       yard (>= 0.9)
-    zeitwerk (2.6.8)
 
 PLATFORMS
   arm64-darwin-22
+  arm64-darwin-23
   x86_64-linux
 
 DEPENDENCIES
   debug
   minitest
   rake
-  rubocop
-  rubocop-minitest
-  rubocop-rake
-  rubocop-sorbet
   sorbet
   sorbet-result!
   sorbet-runtime
   spoom
+  standard
+  standard-sorbet
   tapioca
 
 BUNDLED WITH

data/README.md

@@ -127,6 +127,29 @@ res = retrieve_user(user_id)
 
 If the above chain does not fail, the `puts` statement is never run. If the chain does yield a `Failure`, the `puts` block is executed and the `Failure` is ultimately returned.
 
+### Testing
+
+We ship with a few Minitest assertions that can be used to easily verify Results.
+
+```ruby
+# test_helper.rb
+
+require "minitest/results_assertions"
+# You also need add this to `sorbet/tapioca/require.rb` and rebuild the Minitest gem RBIs
+
+# *_test.rb
+
+@success = Typed::Success.new("Test Payload")
+@failure = Typed::Failure.new("Test Error")
+
+assert_success(@success)
+assert_failure(@failure)
+assert_payload("Test Payload", @success)
+assert_error("Test Error", @failure)
+
+# We also have the `refute_*` counterparts
+```
+
 ## Why use Results?
 
 Let's say you're working on a method that reaches out to an API and fetches a resource. We hope to get a successful response and continue on in our program, but you can imagine several scenarios where we don't get that response: our authentication could fail, the server could return a 5XX response code, or the resource we were querying could have moved or not exist any more.

data/Rakefile

@@ -7,15 +7,13 @@ Minitest::TestTask.create do |t|
   t.test_globs = ["test/**/*_test.rb"]
 end
 
+require "standard/rake"
+
 desc "Test Compiler output"
 task :compiler do
   sh "./test/test_type_checker.sh"
 end
 
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
 desc "Run tapioca compilers"
 task :tapioca do
   sh "bin/tapioca gem"
@@ -26,4 +24,4 @@ task :sorbet do
   sh "bundle exec srb tc"
 end
 
-task default: %i[rubocop:autocorrect_all sorbet test compiler]
+task default: %i[standard:fix_unsafely sorbet test compiler]

data/lib/minitest/result_assertions.rb

@@ -0,0 +1,48 @@
+# typed: true
+
+require "minitest/assertions"
+require "sorbet-result"
+
+module Minitest
+  module Assertions
+    # Fails unless Result is a Success
+    def assert_success(result)
+      assert_kind_of(Typed::Success, result)
+    end
+
+    # Fails unless Result is a Failure
+    def assert_failure(result)
+      assert_kind_of(Typed::Failure, result)
+    end
+
+    # Fails unless exp is equal to payload
+    def assert_payload(exp, result)
+      assert_equal(exp, result.payload)
+    end
+
+    # Fails unless exp is equal to error
+    def assert_error(exp, result)
+      assert_equal(exp, result.error)
+    end
+
+    # Fails if Result is a Success
+    def refute_success(result)
+      refute_kind_of(Typed::Success, result)
+    end
+
+    # Fails if Result is a Failure
+    def refute_failure(result)
+      refute_kind_of(Typed::Failure, result)
+    end
+
+    # Fails if exp is equal to payload
+    def refute_payload(exp, result)
+      refute_equal(exp, result.payload)
+    end
+
+    # Fails if exp is equal to error
+    def refute_error(exp, result)
+      refute_equal(exp, result.error)
+    end
+  end
+end

data/lib/sorbet-result.rb

@@ -4,11 +4,7 @@
 # frozen_string_literal: true
 
 require "sorbet-runtime"
-require "zeitwerk"
+require_relative "typed/result"
 
 # Sorbet-aware namespace to super-charge your projects
 module Typed; end
-
-loader = Zeitwerk::Loader.new
-loader.push_dir("#{__dir__}/typed", namespace: Typed)
-loader.setup

data/lib/typed/result.rb

@@ -1,6 +1,9 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative "no_error_on_success_error"
+require_relative "no_payload_on_failure_error"
+
 module Typed
   # A monad representing either a success or a failure. Contains payload and error information as well.
   class Result
@@ -9,21 +12,26 @@ module Typed
     extend T::Generic
 
     abstract!
+    sealed!
 
     Payload = type_member(:out)
     Error = type_member(:out)
 
     sig { abstract.returns(T::Boolean) }
-    def success?; end
+    def success?
+    end
 
     sig { abstract.returns(T::Boolean) }
-    def failure?; end
+    def failure?
+    end
 
     sig { abstract.returns(Payload) }
-    def payload; end
+    def payload
+    end
 
     sig { abstract.returns(Error) }
-    def error; end
+    def error
+    end
 
     sig do
       abstract
@@ -31,14 +39,16 @@ module Typed
         .params(_block: T.proc.params(arg0: Payload).returns(Result[T.type_parameter(:U), T.type_parameter(:T)]))
         .returns(T.any(Result[T.type_parameter(:U), T.type_parameter(:T)], Result[T.type_parameter(:U), Error]))
     end
-    def and_then(&_block); end
+    def and_then(&_block)
+    end
 
     sig do
       abstract
         .params(block: T.proc.params(arg0: Error).void)
         .returns(T.self_type)
     end
-    def on_error(&block); end
+    def on_error(&block)
+    end
 
     sig do
       abstract
@@ -46,6 +56,158 @@ module Typed
         .params(value: T.type_parameter(:Fallback))
         .returns(T.any(Payload, T.type_parameter(:Fallback)))
     end
-    def payload_or(value); end
+    def payload_or(value)
+    end
+  end
+
+  class Success < Result
+    extend T::Sig
+    extend T::Generic
+
+    Payload = type_member
+    Error = type_member { {fixed: T.noreturn} }
+
+    sig { override.returns(Payload) }
+    attr_reader :payload
+
+    sig do
+      type_parameters(:T)
+        .params(payload: T.type_parameter(:T))
+        .returns(Typed::Success[T.type_parameter(:T)])
+    end
+    def self.new(payload)
+      super(payload)
+    end
+
+    sig { returns(Typed::Success[NilClass]) }
+    def self.blank
+      new(nil)
+    end
+
+    sig { params(payload: Payload).void }
+    def initialize(payload)
+      @payload = payload
+      super()
+    end
+
+    sig { override.returns(T::Boolean) }
+    def success?
+      true
+    end
+
+    sig { override.returns(T::Boolean) }
+    def failure?
+      false
+    end
+
+    sig { override.returns(T.noreturn) }
+    def error
+      raise NoErrorOnSuccessError
+    end
+
+    sig do
+      override
+        .type_parameters(:U, :T)
+        .params(block: T.proc.params(arg0: Payload).returns(Result[T.type_parameter(:U), T.type_parameter(:T)]))
+        .returns(Result[T.type_parameter(:U), T.type_parameter(:T)])
+    end
+    def and_then(&block)
+      block.call(payload)
+    end
+
+    sig do
+      override
+        .params(_block: T.proc.params(arg0: Error).void)
+        .returns(T.self_type)
+    end
+    def on_error(&_block)
+      self
+    end
+
+    sig do
+      override
+        .type_parameters(:Fallback)
+        .params(_value: T.type_parameter(:Fallback))
+        .returns(T.any(Payload, T.type_parameter(:Fallback)))
+    end
+    def payload_or(_value)
+      payload
+    end
+  end
+
+  class Failure < Result
+    extend T::Sig
+    extend T::Generic
+
+    Payload = type_member { {fixed: T.noreturn} }
+    Error = type_member
+
+    sig { override.returns(Error) }
+    attr_reader :error
+
+    sig do
+      type_parameters(:T)
+        .params(error: T.type_parameter(:T))
+        .returns(Typed::Failure[T.type_parameter(:T)])
+    end
+    def self.new(error)
+      super(error)
+    end
+
+    sig { returns(Typed::Failure[NilClass]) }
+    def self.blank
+      new(nil)
+    end
+
+    sig { params(error: Error).void }
+    def initialize(error)
+      @error = error
+      super()
+    end
+
+    sig { override.returns(T::Boolean) }
+    def success?
+      false
+    end
+
+    sig { override.returns(T::Boolean) }
+    def failure?
+      true
+    end
+
+    sig { override.returns(T.noreturn) }
+    def payload
+      raise NoPayloadOnFailureError
+    end
+
+    sig do
+      override
+        .type_parameters(:U, :T)
+        .params(_block: T.proc.params(arg0: Payload).returns(Result[T.type_parameter(:U), T.type_parameter(:T)]))
+        .returns(Result[T.type_parameter(:U), Error])
+    end
+    def and_then(&_block)
+      self
+    end
+
+    sig do
+      override
+        .params(block: T.proc.params(arg0: Error).void)
+        .returns(T.self_type)
+    end
+    def on_error(&block)
+      block.call(error)
+      self
+    end
+
+    sig do
+      override
+        .type_parameters(:Fallback)
+        .params(value: T.type_parameter(:Fallback))
+        .returns(T.any(Payload, T.type_parameter(:Fallback)))
+    end
+    def payload_or(value)
+      value
+    end
   end
 end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true