mangrove 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d9363cc1b8f639fb866ae374f0e64ffe380d3b35b169f3d62311e2a59580736
-  data.tar.gz: d467281c91693bbb7ba35996ce578e5af4e0698268603973e84340317fa6e677
+  metadata.gz: 06e20e8a9945c52ddba260f01fa12a7f8e65fda55fe2a369f85eb296b428eeb7
+  data.tar.gz: 524eba3f2d942063c597568e7d432f18cff9f6e5b85efc5eeadb3d055eaaac46
 SHA512:
-  metadata.gz: ebe32cf0d3682642244a3a44ee132dab4a3cf09c79a67f4e4638a5e262b918a8510da53f9600cc1b86c152949923b6c4503ed62175f9bce2579646401e631f50
-  data.tar.gz: ebcef49659e1251716a7da1d111eb691b4468d57ac8ab073775a7f6719794ac20f09b37e6619b30200432cca068f99818869d891eb3fb52620fd2556875011ab
+  metadata.gz: 88cbb663b866dfd8fb559adc76b847a8501e1d96c237e0ef919c339381f142f4ce7a91482770bd239e2f68588793171c900e9b87a57f50f0c290d9982f944b2c
+  data.tar.gz: 9c1b5d530382de4eeeeb2cf20e0a18abd184a0dbd10cbf66fef190f1d897026863449afa56fa0de4d34cb594659d00a93e5eab2ae6ec548050dbcb3ce20321d2

data/.rubocop.yml

@@ -9,6 +9,9 @@ Layout/FirstArrayElementIndentation:
 Layout/LineLength:
   Enabled: false
 
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
 Metrics/AbcSize:
   Enabled: false
 
@@ -27,6 +30,13 @@ Metrics/ModuleLength:
 Naming/VariableNumber:
   EnforcedStyle: snake_case
 
+Style/BlockDelimiters:
+  EnforcedStyle: always_braces
+  AllowedMethods:
+  - describe
+  - context
+  - it
+
 Style/Documentation:
   Enabled: false
 

data/README.md

@@ -1,5 +1,35 @@
 # Mangrove
-Mangrove provides utility types to use with Sorbet
+Mangrove provides type utility to use with Sorbet.
+
+You can do something like this with the gem.
+
+```ruby
+class MyClass
+  extend T::Sig
+
+  include Mangrove::ControlFlow::Handler
+
+  sig { params(numbers: T::Enumerable[Integer]).returns(Mangrove::Result[T::Array[Integer], String]) }
+  def divide_arguments_by_3(numbers)
+    divided_nubmers = numbers
+      .map { |number|
+        if number % 3 == 0
+          Mangrove::Result::Ok.new(number / 3)
+        else
+          Mangrove::Result::Err.new("number #{number} is not divisible by 3")
+        end
+      }
+      .map(&:unwrap!)
+
+    Mangrove::Result::Ok.new(divided_nubmers)
+  end
+end
+
+expect(MyClass.new.divide_arguments_by_3([3, 4, 6])).to eq Mangrove::Result::Err.new("number 4 is not divisible by 3")
+expect(MyClass.new.divide_arguments_by_3([3, 6, 9])).to eq Mangrove::Result::Ok.new([1, 2, 3])
+```
+
+Other examples are available at `spec/**/**_spec.rb`.
 
 ## Features
 Most features are not implemented.
@@ -10,24 +40,34 @@ Most features are not implemented.
   - [x] Auto propagation like Rust's `?` (formerly `try!`)
 - [ ] Builder type (Not implemented)
   - [ ] Auto Implementation
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mangrove`. To experiment with that code, run `bin/console` for an interactive prompt.
+- [ ] TODO
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
-Install the gem and add to the application's Gemfile by executing:
+```
+bundle add mangrove
+```
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+## Usage
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+see `spec/**/**_spec.rb`.
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+```ruby
+Mangrove::Result[OkType, ErrType]
+Mangrove::Result::Ok[OkType, ErrType]
+Mangrove::Result::Err[OkType, ErrType]
+Mangrove::Option[InnerType]
+Mangrove::Option::Some[InnerType]
+Mangrove::Option::None[InnerType]
 
-## Usage
+my_ok = Result::Ok.new("my value")
+my_err = Result::Err.new("my err")
+my_some = Option::Some.new(1234)
+my_none = Option::None.new
 
-TODO: Write usage instructions here
+# Including this Module into your class appends rescue clause into its methods. Results to `Option#unwrap!` and `Result#unwrap!` propagates to calling method like Ruet's `?` operator.
+include Mangrove::ControlFlow::Handler
+```
 
 ## Commands
 ```
@@ -53,4 +93,4 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/mangrove.
+Bug reports and pull requests are welcome on GitHub at https://github.com/kazzix14/mangrove.

data/Rakefile

@@ -3,12 +3,12 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-task :check do
+task(:check) {
   system("bundle exec ordinare --check") &&
     system("bundle exec rubocop -DESP") &&
     system("bundle exec tapioca check-shims") &&
     system("bundle exec srb typecheck") &&
     system("bundle exec rspec -f d")
-end
+}
 
 task default: :check

data/lib/mangrove/control_flow/rewriter.rb

@@ -127,7 +127,7 @@ module Mangrove
       end
 
       def rescue_body_node
-        control_flow = StandardError
+        control_flow = Mangrove::ControlFlow::ControlSignal
 
         ::Parser::AST::Node.new(:resbody, [
           ::Parser::AST::Node.new(:array, [
@@ -143,7 +143,10 @@ module Mangrove
               :Err
             ]),
             :new,
-            ::Parser::AST::Node.new(:lvar, [:exception])
+            ::Parser::AST::Node.new(:send, [
+              ::Parser::AST::Node.new(:lvar, [:exception]),
+              :inner_value
+            ])
           ])
         ])
       end

data/lib/mangrove/result.rb

@@ -47,7 +47,7 @@ module Mangrove
       end
 
       sig { returns(OkType) }
-      def unwrap
+      def ok_inner
         @inner
       end
 
@@ -106,14 +106,19 @@ module Mangrove
         end
       end
 
+      sig { returns(ErrType) }
+      def err_inner
+        @inner
+      end
+
       sig { override.returns(OkType) }
       def unwrap!
-        raise Result::ControlSignal, Result::Err.new("called `Result#unwrap!` on an `Err` value: #{self}")
+        raise Result::ControlSignal, @inner
       end
 
       sig { override.params(message: String).returns(OkType) }
       def expect!(message)
-        raise Result::ControlSignal, Result::Err.new(message)
+        raise Result::ControlSignal, message
       end
 
       sig { override.returns(T::Boolean) }
@@ -122,16 +127,12 @@ module Mangrove
       sig { override.returns(T::Boolean) }
       def err? = true
 
-      sig do
-        override.params(_block: T.proc.params(this: OkType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType])
-      end
+      sig { override.params(_block: T.proc.params(this: OkType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
       def map_ok(&_block)
         self
       end
 
-      sig do
-        override.params(block: T.proc.params(this: ErrType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType])
-      end
+      sig { override.params(block: T.proc.params(this: ErrType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
       def map_err(&block)
         block.call(@inner)
       end
@@ -152,16 +153,10 @@ module Mangrove
     sig { abstract.params(message: String).returns(OkType) }
     def expect!(message); end
 
-    sig do
-      abstract.params(block: T.proc.params(this: OkType).returns(Result[OkType,
-                                                                        ErrType])).returns(Result[OkType, ErrType])
-    end
+    sig { abstract.params(block: T.proc.params(this: OkType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
     def map_ok(&block); end
 
-    sig do
-      abstract.params(block: T.proc.params(this: ErrType).returns(Result[OkType,
-                                                                         ErrType])).returns(Result[OkType, ErrType])
-    end
+    sig { abstract.params(block: T.proc.params(this: ErrType).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
     def map_err(&block); end
   end
 end

data/lib/mangrove/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mangrove
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kazuma Murata
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-25 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime