mangrove 0.18.0 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cfc3160fc21f4d4a647ffa2626d32fd547e5dd16e85da36614d2aee7705a2f4
-  data.tar.gz: 8f51c89c685e1d9bb33c803237af0de5dfc280812d7312d03cd95483219c3a47
+  metadata.gz: 01155ce389be568b548bdbf4fa40a029c4ff6575f9dfa41bba52c1f75bb2d6c5
+  data.tar.gz: 6af2e06f168ca3406e884e3d751b3c21fecf0fbfc0487bca24fa8e7fca08839d
 SHA512:
-  metadata.gz: 77016fe8709eea630aa24af790d175af9105339724c7145c982a47aa4ceb4f7d84a5fe15f39f56c4a23aaf7e93a8e020d4b5843ca844fc5ddfdbe48200604e45
-  data.tar.gz: 75aae8968e35d34c7c2c69a16d822d0a65b0b79e0587623ad3520188e66c423a0aa7dad24b42060c37901c5b0d1e714806c5b78737249c781e77266f84a1806c
+  metadata.gz: 12df1c2a68dd9ffdc95a24a3db8ef1d651da0bdc557ec608ed2240d2f1efd2728f831a31a3843eb2dc34eb25559787e3dc6e09f1aad5c6aecd0a38d26eee7fa2
+  data.tar.gz: 29e3d2fe898d9c5a7376001b2b6f7844ad7ecd55a49efd18caed98fc4ddf09cbd05dc274f118486d7fc5ba491944d055c9dc319949ee001e5339c45b8d674639

data/README.md

@@ -2,6 +2,9 @@
 Mangrove provides type utility to use with Sorbet.
 use `rubocop-mangrove` to statically check rescuing ControlSignal is done
 
+- [Documentation](https://kazzix14.github.io/mangrove/docs/)
+- [Coverage](https://kazzix14.github.io/mangrove/coverage/index.html#_AllFiles)
+
 You can do something like this with the gem.
 ```ruby
 class TransposeExample

data/lib/mangrove/result.rb

@@ -69,6 +69,18 @@ module Mangrove
     sig { abstract.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
     def and_then_wt(_t_new_ok, &block); end
 
+    sig {
+      abstract
+        .params(
+          new_err_inner: ErrType,
+          condition: T.proc.params(inner: OkType).returns(T::Boolean)
+        )
+        .returns(
+          Result[OkType, ErrType]
+        )
+    }
+    def and_err_if(new_err_inner, &condition); end
+
     sig { abstract.params(other: Result[OkType, ErrType]).returns(Result[OkType, ErrType]) }
     def or(other); end
 
@@ -78,6 +90,18 @@ module Mangrove
     sig { abstract.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
     def or_else_wt(_t_new_err, &block); end
 
+    sig {
+      abstract
+        .params(
+          new_ok_inner: OkType,
+          condition: T.proc.params(inner: ErrType).returns(T::Boolean)
+        )
+        .returns(
+          Result[OkType, ErrType]
+        )
+    }
+    def or_ok_if(new_ok_inner, &condition); end
+
     class << self
       extend T::Sig
       extend T::Generic
@@ -198,7 +222,7 @@ module Mangrove
         Result::Ok[T.type_parameter(:NewOkType), ErrType].new(block.call(@inner))
       end
 
-      # Because sorbet deduct types from return values well. This method takes a type of new inner values.
+      # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def map_ok_wt(_t_new_ok, &block)
         Result::Ok[T.type_parameter(:NewOkType), ErrType].new(block.call(@inner))
@@ -209,7 +233,7 @@ module Mangrove
         T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
       end
 
-      # Because sorbet deduct types from return values well. This method takes a type of new inner values.
+      # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], _block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def map_err_wt(_t_new_err, &_block)
         T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
@@ -230,6 +254,24 @@ module Mangrove
         block.call(@inner)
       end
 
+      sig {
+        override
+          .params(
+            new_err_inner: ErrType,
+            condition: T.proc.params(inner: OkType).returns(T::Boolean)
+          )
+          .returns(
+            Result[OkType, ErrType]
+          )
+      }
+      def and_err_if(new_err_inner, &condition)
+        if condition.call(@inner)
+          Result::Err[OkType, ErrType].new(new_err_inner)
+        else
+          self
+        end
+      end
+
       sig { override.params(_other: Result[OkType, ErrType]).returns(Result[OkType, ErrType]) }
       def or(_other)
         self
@@ -245,6 +287,20 @@ module Mangrove
         T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
       end
 
+      sig {
+        override
+          .params(
+            _new_ok_inner: OkType,
+            _condition: T.proc.params(inner: ErrType).returns(T::Boolean)
+          )
+          .returns(
+            Result::Ok[OkType, ErrType]
+          )
+      }
+      def or_ok_if(_new_ok_inner, &_condition)
+        self
+      end
+
       sig { returns(String) }
       def to_s
         "#{super}: inner=`#{@inner}`"
@@ -330,7 +386,7 @@ module Mangrove
         T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
       end
 
-      # Because sorbet deduct types from return values well. This method takes a type of new inner values.
+      # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def map_ok_wt(_t_new_ok, &_block)
         T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
@@ -341,6 +397,7 @@ module Mangrove
         Result::Err[OkType, T.type_parameter(:NewErrType)].new(block.call(@inner))
       end
 
+      # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def map_err_wt(_t_new_err, &block)
         Result::Err[OkType, T.type_parameter(:NewErrType)].new(block.call(@inner))
@@ -361,6 +418,20 @@ module Mangrove
         T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
       end
 
+      sig {
+        override
+          .params(
+            _new_err_inner: ErrType,
+            _condition: T.proc.params(inner: OkType).returns(T::Boolean)
+          )
+          .returns(
+            Result::Err[OkType, ErrType]
+          )
+      }
+      def and_err_if(_new_err_inner, &_condition)
+        self
+      end
+
       sig { override.params(other: Result[OkType, ErrType]).returns(Result[OkType, ErrType]) }
       def or(other)
         other
@@ -376,6 +447,24 @@ module Mangrove
         block.call(@inner)
       end
 
+      sig {
+        override
+          .params(
+            new_ok_inner: OkType,
+            condition: T.proc.params(inner: ErrType).returns(T::Boolean)
+          )
+          .returns(
+            Result[OkType, ErrType]
+          )
+      }
+      def or_ok_if(new_ok_inner, &condition)
+        if condition.call(@inner)
+          Result::Ok[OkType, ErrType].new(new_ok_inner)
+        else
+          self
+        end
+      end
+
       sig { returns(String) }
       def to_s
         "#{super}: inner=`#{@inner}`"

data/lib/mangrove/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Mangrove
-  VERSION = "0.18.0"
+  VERSION = "0.19.1"
 end

data/sorbet/rbi/annotations/.gitattributes

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

data/sorbet/rbi/gems/diff-lcs@1.5.0.rbi

@@ -522,7 +522,7 @@ Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array)
 # elements in the old and the new sequenced enumerables as well as the action
 # taken.
 #
-# source://diff-lcs//lib/diff/lcs/change.rb#100
+# source://diff-lcs//lib/diff/lcs/change.rb#101
 class Diff::LCS::ContextChange < ::Diff::LCS::Change
   # @return [ContextChange] a new instance of ContextChange
   #
@@ -692,10 +692,6 @@ class Diff::LCS::DefaultCallbacks
     #
     # source://diff-lcs//lib/diff/lcs/callbacks.rb#17
     def match(event); end
-
-    private
-
-    def new(*_arg0); end
   end
 end
 

data/sorbet/rbi/gems/docile@1.4.0.rbi

@@ -0,0 +1,376 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `docile` gem.
+# Please instead update this file by running `bin/tapioca gem docile`.
+
+# Docile keeps your Ruby DSLs tame and well-behaved.
+#
+# source://docile//lib/docile/version.rb#3
+module Docile
+  extend ::Docile::Execution
+
+  private
+
+  # Execute a block in the context of an object whose methods represent the
+  # commands in a DSL.
+  #
+  # Use this method to execute an *imperative* DSL, which means that:
+  #
+  #   1. Each command mutates the state of the DSL context object
+  #   2. The return value of each command is ignored
+  #   3. The final return value is the original context object
+  #
+  # @example Use a String as a DSL
+  #   Docile.dsl_eval("Hello, world!") do
+  #   reverse!
+  #   upcase!
+  #   end
+  #   #=> "!DLROW ,OLLEH"
+  # @example Use an Array as a DSL
+  #   Docile.dsl_eval([]) do
+  #   push 1
+  #   push 2
+  #   pop
+  #   push 3
+  #   end
+  #   #=> [1, 3]
+  # @note Use with an *imperative* DSL (commands modify the context object)
+  # @param dsl [Object] context object whose methods make up the DSL
+  # @param args [Array] arguments to be passed to the block
+  # @param block [Proc] the block of DSL commands to be executed against the
+  #   `dsl` context object
+  # @return [Object] the `dsl` context object after executing the block
+  #
+  # source://docile//lib/docile.rb#45
+  def dsl_eval(dsl, *args, **_arg2, &block); end
+
+  # Execute a block in the context of an immutable object whose methods,
+  # and the methods of their return values, represent the commands in a DSL.
+  #
+  # Use this method to execute a *functional* DSL, which means that:
+  #
+  #   1. The original DSL context object is never mutated
+  #   2. Each command returns the next DSL context object
+  #   3. The final return value is the value returned by the last command
+  #
+  # @example Use a frozen String as a DSL
+  #   Docile.dsl_eval_immutable("I'm immutable!".freeze) do
+  #   reverse
+  #   upcase
+  #   end
+  #   #=> "!ELBATUMMI M'I"
+  # @example Use a Float as a DSL
+  #   Docile.dsl_eval_immutable(84.5) do
+  #   fdiv(2)
+  #   floor
+  #   end
+  #   #=> 42
+  # @note Use with a *functional* DSL (commands return successor
+  #   context objects)
+  # @param dsl [Object] immutable context object whose methods make up the
+  #   initial DSL
+  # @param args [Array] arguments to be passed to the block
+  # @param block [Proc] the block of DSL commands to be executed against the
+  #   `dsl` context object and successor return values
+  # @return [Object] the return value of the final command in the block
+  #
+  # source://docile//lib/docile.rb#128
+  def dsl_eval_immutable(dsl, *args, **_arg2, &block); end
+
+  # Execute a block in the context of an object whose methods represent the
+  # commands in a DSL, and return *the block's return value*.
+  #
+  # Use this method to execute an *imperative* DSL, which means that:
+  #
+  #   1. Each command mutates the state of the DSL context object
+  #   2. The return value of each command is ignored
+  #   3. The final return value is the original context object
+  #
+  # @example Use a String as a DSL
+  #   Docile.dsl_eval_with_block_return("Hello, world!") do
+  #   reverse!
+  #   upcase!
+  #   first
+  #   end
+  #   #=> "!"
+  # @example Use an Array as a DSL
+  #   Docile.dsl_eval_with_block_return([]) do
+  #   push "a"
+  #   push "b"
+  #   pop
+  #   push "c"
+  #   length
+  #   end
+  #   #=> 2
+  # @note Use with an *imperative* DSL (commands modify the context object)
+  # @param dsl [Object] context object whose methods make up the DSL
+  # @param args [Array] arguments to be passed to the block
+  # @param block [Proc] the block of DSL commands to be executed against the
+  #   `dsl` context object
+  # @return [Object] the return value from executing the block
+  #
+  # source://docile//lib/docile.rb#87
+  def dsl_eval_with_block_return(dsl, *args, **_arg2, &block); end
+
+  class << self
+    # Execute a block in the context of an object whose methods represent the
+    # commands in a DSL.
+    #
+    # Use this method to execute an *imperative* DSL, which means that:
+    #
+    #   1. Each command mutates the state of the DSL context object
+    #   2. The return value of each command is ignored
+    #   3. The final return value is the original context object
+    #
+    # @example Use a String as a DSL
+    #   Docile.dsl_eval("Hello, world!") do
+    #   reverse!
+    #   upcase!
+    #   end
+    #   #=> "!DLROW ,OLLEH"
+    # @example Use an Array as a DSL
+    #   Docile.dsl_eval([]) do
+    #   push 1
+    #   push 2
+    #   pop
+    #   push 3
+    #   end
+    #   #=> [1, 3]
+    # @note Use with an *imperative* DSL (commands modify the context object)
+    # @param dsl [Object] context object whose methods make up the DSL
+    # @param args [Array] arguments to be passed to the block
+    # @param block [Proc] the block of DSL commands to be executed against the
+    #   `dsl` context object
+    # @return [Object] the `dsl` context object after executing the block
+    #
+    # source://docile//lib/docile.rb#45
+    def dsl_eval(dsl, *args, **_arg2, &block); end
+
+    # Execute a block in the context of an immutable object whose methods,
+    # and the methods of their return values, represent the commands in a DSL.
+    #
+    # Use this method to execute a *functional* DSL, which means that:
+    #
+    #   1. The original DSL context object is never mutated
+    #   2. Each command returns the next DSL context object
+    #   3. The final return value is the value returned by the last command
+    #
+    # @example Use a frozen String as a DSL
+    #   Docile.dsl_eval_immutable("I'm immutable!".freeze) do
+    #   reverse
+    #   upcase
+    #   end
+    #   #=> "!ELBATUMMI M'I"
+    # @example Use a Float as a DSL
+    #   Docile.dsl_eval_immutable(84.5) do
+    #   fdiv(2)
+    #   floor
+    #   end
+    #   #=> 42
+    # @note Use with a *functional* DSL (commands return successor
+    #   context objects)
+    # @param dsl [Object] immutable context object whose methods make up the
+    #   initial DSL
+    # @param args [Array] arguments to be passed to the block
+    # @param block [Proc] the block of DSL commands to be executed against the
+    #   `dsl` context object and successor return values
+    # @return [Object] the return value of the final command in the block
+    #
+    # source://docile//lib/docile.rb#128
+    def dsl_eval_immutable(dsl, *args, **_arg2, &block); end
+
+    # Execute a block in the context of an object whose methods represent the
+    # commands in a DSL, and return *the block's return value*.
+    #
+    # Use this method to execute an *imperative* DSL, which means that:
+    #
+    #   1. Each command mutates the state of the DSL context object
+    #   2. The return value of each command is ignored
+    #   3. The final return value is the original context object
+    #
+    # @example Use a String as a DSL
+    #   Docile.dsl_eval_with_block_return("Hello, world!") do
+    #   reverse!
+    #   upcase!
+    #   first
+    #   end
+    #   #=> "!"
+    # @example Use an Array as a DSL
+    #   Docile.dsl_eval_with_block_return([]) do
+    #   push "a"
+    #   push "b"
+    #   pop
+    #   push "c"
+    #   length
+    #   end
+    #   #=> 2
+    # @note Use with an *imperative* DSL (commands modify the context object)
+    # @param dsl [Object] context object whose methods make up the DSL
+    # @param args [Array] arguments to be passed to the block
+    # @param block [Proc] the block of DSL commands to be executed against the
+    #   `dsl` context object
+    # @return [Object] the return value from executing the block
+    #
+    # source://docile//lib/docile.rb#87
+    def dsl_eval_with_block_return(dsl, *args, **_arg2, &block); end
+  end
+end
+
+# This is used to remove entries pointing to Docile's source files
+# from {Exception#backtrace} and {Exception#backtrace_locations}.
+#
+# If {NoMethodError} is caught then the exception object will be extended
+# by this module to add filter functionalities.
+#
+# @api private
+#
+# source://docile//lib/docile/backtrace_filter.rb#11
+module Docile::BacktraceFilter
+  # @api private
+  #
+  # source://docile//lib/docile/backtrace_filter.rb#14
+  def backtrace; end
+
+  # @api private
+  #
+  # source://docile//lib/docile/backtrace_filter.rb#19
+  def backtrace_locations; end
+end
+
+# @api private
+#
+# source://docile//lib/docile/backtrace_filter.rb#12
+Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# Operates in the same manner as {FallbackContextProxy}, but replacing
+# the primary `receiver` object with the result of each proxied method.
+#
+# This is useful for implementing DSL evaluation for immutable context
+# objects.
+#
+#
+# @api private
+# @see Docile.dsl_eval_immutable
+#
+# source://docile//lib/docile/chaining_fallback_context_proxy.rb#19
+class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy
+  # Proxy methods as in {FallbackContextProxy#method_missing}, replacing
+  # `receiver` with the returned value.
+  #
+  # @api private
+  #
+  # source://docile//lib/docile/chaining_fallback_context_proxy.rb#20
+  def method_missing(method, *args, **_arg2, &block); end
+end
+
+# A namespace for functions relating to the execution of a block against a
+# proxy object.
+#
+# @api private
+#
+# source://docile//lib/docile/execution.rb#8
+module Docile::Execution
+  private
+
+  # Execute a block in the context of an object whose methods represent the
+  # commands in a DSL, using a specific proxy class.
+  #
+  # @api private
+  # @param dsl [Object] context object whose methods make up the
+  #   (initial) DSL
+  # @param proxy_type [FallbackContextProxy, ChainingFallbackContextProxy] which class to instantiate as proxy context
+  # @param args [Array] arguments to be passed to the block
+  # @param block [Proc] the block of DSL commands to be executed
+  # @return [Object] the return value of the block
+  #
+  # source://docile//lib/docile/execution.rb#19
+  def exec_in_proxy_context(dsl, proxy_type, *args, **_arg3, &block); end
+
+  class << self
+    # Execute a block in the context of an object whose methods represent the
+    # commands in a DSL, using a specific proxy class.
+    #
+    # @api private
+    # @param dsl [Object] context object whose methods make up the
+    #   (initial) DSL
+    # @param proxy_type [FallbackContextProxy, ChainingFallbackContextProxy] which class to instantiate as proxy context
+    # @param args [Array] arguments to be passed to the block
+    # @param block [Proc] the block of DSL commands to be executed
+    # @return [Object] the return value of the block
+    #
+    # source://docile//lib/docile/execution.rb#19
+    def exec_in_proxy_context(dsl, proxy_type, *args, **_arg3, &block); end
+  end
+end
+
+# A proxy object with a primary receiver as well as a secondary
+# fallback receiver.
+#
+# Will attempt to forward all method calls first to the primary receiver,
+# and then to the fallback receiver if the primary does not handle that
+# method.
+#
+# This is useful for implementing DSL evaluation in the context of an object.
+#
+#
+# @api private
+# @see Docile.dsl_eval
+#
+# source://docile//lib/docile/fallback_context_proxy.rb#20
+class Docile::FallbackContextProxy
+  # @api private
+  # @param receiver [Object] the primary proxy target to which all methods
+  #   initially will be forwarded
+  # @param fallback [Object] the fallback proxy target to which any methods
+  #   not handled by `receiver` will be forwarded
+  # @return [FallbackContextProxy] a new instance of FallbackContextProxy
+  #
+  # source://docile//lib/docile/fallback_context_proxy.rb#46
+  def initialize(receiver, fallback); end
+
+  # @api private
+  # @return [Array<Symbol>] Instance variable names, excluding
+  #   {NON_PROXIED_INSTANCE_VARIABLES}
+  #
+  # source://docile//lib/docile/fallback_context_proxy.rb#85
+  def instance_variables; end
+
+  # Proxy all methods, excluding {NON_PROXIED_METHODS}, first to `receiver`
+  # and then to `fallback` if not found.
+  #
+  # @api private
+  #
+  # source://docile//lib/docile/fallback_context_proxy.rb#91
+  def method_missing(method, *args, **_arg2, &block); end
+end
+
+# The set of methods which will **not** fallback from the block's context
+# to the dsl object.
+#
+# @api private
+#
+# source://docile//lib/docile/fallback_context_proxy.rb#30
+Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set)
+
+# The set of instance variables which are local to this object and hidden.
+# All other instance variables will be copied in and out of this object
+# from the scope in which this proxy was created.
+#
+# @api private
+#
+# source://docile//lib/docile/fallback_context_proxy.rb#35
+Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set)
+
+# The set of methods which will **not** be proxied, but instead answered
+# by this object directly.
+#
+# @api private
+#
+# source://docile//lib/docile/fallback_context_proxy.rb#23
+Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set)
+
+# The current version of this library
+#
+# source://docile//lib/docile/version.rb#5
+Docile::VERSION = T.let(T.unsafe(nil), String)