sorbet-result 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79770af90bc94993111e0e11b8d4dfcf7660d19e878a1f55642e607fcc6db579
-  data.tar.gz: eb5c66753067b295ed7750aec1a0de64630c9f0fe5d5f5e3f20b5f3d66b33de2
+  metadata.gz: 62795733b699fe9adec850e9584a6c45c47e6fa00daa93cb93221a43ca16b131
+  data.tar.gz: 3b0f4ef2e5fc20e61e88724dc6e6637f254f41ec6394b802896f30861c9a40cb
 SHA512:
-  metadata.gz: 75311c18528aa78e426b0f497d4a5d6bb69dc859811b1bfe27201df062422243f2ba091c232141baa13d8a5092e10dc52d11e6e3654b7bc47979e0d88a306e63
-  data.tar.gz: 0e76944518d89dfa80d5025590ccb4c6867977edcf4ae626f155a5b8ce8cc1e52b1a8d61186e9e24c9d0d13af9fca51612374a178ef91ebe6ef672bd9b59efd1
+  metadata.gz: 59395f384a03d978f128695fc2cf9c1b79a34b91e0c0aeae0e995b9a3ecc440901ff599112d14d06cab99a92cd0dd82ff8831d7d852255ae9ed5f872a14cc17f
+  data.tar.gz: d536a970dc7c60490c6a106178c1e32ef61cfb816d46405fb389dd62d43e0f5d8ac1e7b6a7097aa73b225d4752ab702bc75bafe25b3f365ba08f7d67c1137e75

data/.ruby-version

@@ -1 +1 @@
-3.2.2
+3.3.5

data/.standard.yml

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

data/.tool-versions

@@ -1 +1 @@
-ruby 3.2.2
+ruby 3.3.5

data/CHANGELOG.md

@@ -6,6 +6,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.0] - 2024-11-03
+
+### Added
+
+- Add `Typed::Success(payload)` and `Typed::Failure(error)` convenience method (no more `.new`-ing!)
+- Add `Typed::Success#==` and `Typed::Failure#==` implementations
+
+### Removed
+
+- **POTENTIALLY BREAKING** Remove support for Ruby < 3.1.
+
+## [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

@@ -2,15 +2,13 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in activerecord-ejection_seat.gemspec
+# Specify your gem's dependencies in sorbet-result.gemspec
 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,108 +1,123 @@
 PATH
   remote: .
   specs:
-    sorbet-result (1.0.0)
+    sorbet-result (1.2.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.2)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    erubi (1.13.0)
+    io-console (0.7.2)
+    irb (1.14.1)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.7.5)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    minitest (5.25.1)
     netrc (0.11.0)
-    parallel (1.23.0)
-    parser (3.2.2.3)
+    parallel (1.26.3)
+    parser (3.3.5.1)
       ast (~> 2.4.1)
       racc
-    racc (1.7.1)
+    prism (1.2.0)
+    psych (5.1.2)
+      stringio
+    racc (1.8.1)
     rainbow (3.1.1)
-    rake (13.0.6)
-    rbi (0.0.16)
-      ast
-      parser (>= 2.6.4.0)
+    rake (13.2.1)
+    rbi (0.2.1)
+      prism (~> 1.0)
       sorbet-runtime (>= 0.5.9204)
-      unparser
-    regexp_parser (2.8.1)
-    reline (0.3.5)
+    rdoc (6.7.0)
+      psych (>= 4.0.0)
+    regexp_parser (2.9.2)
+    reline (0.5.10)
       io-console (~> 0.5)
-    rexml (3.2.5)
-    rubocop (1.52.1)
+    rubocop (1.66.1)
       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)
+      regexp_parser (>= 2.4, < 3.0)
+      rubocop-ast (>= 1.32.2, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.29.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-ast (1.33.1)
+      parser (>= 3.3.1.0)
+    rubocop-performance (1.22.1)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    rubocop-sorbet (0.7.8)
       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.11633)
+      sorbet-static (= 0.5.11633)
+    sorbet-runtime (0.5.11633)
+    sorbet-static (0.5.11633-universal-darwin)
+    sorbet-static (0.5.11633-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11633)
+      sorbet (= 0.5.11633)
+      sorbet-runtime (= 0.5.11633)
+    spoom (1.5.0)
+      erubi (>= 1.10.0)
+      prism (>= 0.28.0)
+      sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
-    tapioca (0.11.6)
+    standard (1.41.1)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.66.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.5)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.5.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.22.0)
+    standard-sorbet (0.0.2)
+      lint_roller (~> 1.1)
+      rubocop-sorbet (~> 0.7.0)
+    stringio (3.1.1)
+    tapioca (0.16.3)
       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)
-      spoom (~> 1.2.0, >= 1.2.0)
+      rbi (~> 0.2)
+      sorbet-static-and-runtime (>= 0.5.11087)
+      spoom (>= 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)
-    yard (0.9.34)
-    yard-sorbet (0.8.1)
-      sorbet-runtime (>= 0.5)
-      yard (>= 0.9)
-    zeitwerk (2.6.8)
+    thor (1.3.2)
+    unicode-display_width (2.6.0)
+    yard (0.9.37)
+    yard-sorbet (0.9.0)
+      sorbet-runtime
+      yard
 
 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
-   2.4.12
+   2.5.18

data/README.md

@@ -78,8 +78,8 @@ result = call_api(1)
 
 result.success? # => true on success, false on failure
 result.failure? # => true on failure, false on success
-result.payload # => nil on failure, payload type on failure
-result.error # => nil on success, error type on failure
+result.payload # => raises error on failure, payload type on success
+result.error # => raises error on success, error type on failure
 result.payload_or("fallback") # => returns payload on success, given value on failure
 
 # You can combine all the above to write flow-sensitive type-checked code
@@ -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/result_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,7 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative "no_error_on_success_error"
+require_relative "no_payload_on_failure_error"
+
 module Typed
+  extend T::Sig
+
   # A monad representing either a success or a failure. Contains payload and error information as well.
   class Result
     extend T::Sig
@@ -9,21 +14,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 +41,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 +58,186 @@ 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
+    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
+
+    sig { params(other: T.untyped).returns(T::Boolean) }
+    def ==(other)
+      other.is_a?(Success) && other.payload == payload
+    end
+  end
+
+  sig do
+    type_parameters(:T)
+      .params(payload: T.type_parameter(:T))
+      .returns(Typed::Success[T.type_parameter(:T)])
+  end
+  def self.Success(payload)
+    Success.new(payload)
+  end
+
+  sig do
+    type_parameters(:T)
+      .params(error: T.type_parameter(:T))
+      .returns(Typed::Failure[T.type_parameter(:T)])
+  end
+  def self.Failure(error)
+    Failure.new(error)
+  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
+    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
+
+    sig { params(other: T.untyped).returns(T::Boolean) }
+    def ==(other)
+      other.is_a?(Failure) && other.error == error
+    end
   end
 end

data/sorbet/rbi/gems/.gitattributes

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

data/sorbet/rbi/gems/ast@2.4.2.rbi

@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `ast` gem.
 # Please instead update this file by running `bin/tapioca gem ast`.
 
+
 # {AST} is a library for manipulating abstract syntax trees.
 #
 # It embraces immutability; each AST node is inherently frozen at