mangrove 0.34.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dfe08aeea0151d419caef995589fe18b98674aeb78817f651d58eef0b45e552
-  data.tar.gz: 070b2971e1f62072b6e26289fe7e04f0f5527c414db63664cb76ef82c19b9ffd
+  metadata.gz: 371d0e77c422e441bc8798ca1aacf77cf11126fcea3bec2aba243c1a4970300f
+  data.tar.gz: 1cc24f3c80fe6c2fdca11c75193df51f7d77be047ecb40f98700b30a6eb5df4a
 SHA512:
-  metadata.gz: 75bc64b315237e3e0c44ce8245a13e4562daf2ac2444cd3aff98151869f3c3f796259b9f62ab3d3b5fc2a58749033e3839e44d86785c20f0ec1a6b3a51e23474
-  data.tar.gz: 60204fffda1d393f5d1b6b0c893c29757d66c14c149685b0e138d2b1e86926da61784315f789c45dcec549dd564cc87f0c7166f9c5f259ce9de05081d41ddac2
+  metadata.gz: 2aa303b678e5a045c0f1b13acd24cbbed698ea69e278b94fb7df2015924f5627cc86841c5769e30434ca613fef2adf489c6b555875dafff8733b593358321ea1
+  data.tar.gz: 62c17b4a366a86ec193b09196af476e58f921edebf1118ac875af70e6a61ca5eaa58e5a764f28f82372a266149be5b02a0af3276e2c8857e1d0699019366073a

data/.rubocop.yml

@@ -31,10 +31,14 @@ Metrics/ModuleLength:
 Naming/BlockForwarding:
   EnforcedStyle: explicit
 
+Naming/MethodParameterName:
+  Enabled: false
+
 Naming/VariableNumber:
   EnforcedStyle: snake_case
 
 Style/BlockDelimiters:
+  Enabled: false
   EnforcedStyle: always_braces
   AllowedMethods:
   - describe
@@ -63,3 +67,4 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
+

data/README.md

@@ -2,22 +2,21 @@
 
 Mangrove is a Ruby toolkit that brings a functional, statically-typed flavor to your Sorbet-enabled projects. Inspired by concepts from languages like Rust and Haskell, Mangrove provides a robust set of tools—primarily `Result` and ADT-like Enums—to help you write safer, more expressive Ruby code.
 
-- **[Documentation](https://kazzix14.github.io/mangrove/docs/)**
-- **[Coverage](https://kazzix14.github.io/mangrove/coverage/index.html#_AllFiles)**
+- [Documentation](https://kazzix14.github.io/mangrove/docs/)
+- [Coverage](https://kazzix14.github.io/mangrove/coverage/index.html#_AllFiles)
 
 ---
 
 ## Highlights
 
 - **Sorbet Integration**
-  Built from the ground up to work smoothly with Sorbet’s type system.
+  Built from the ground up to work smoothly with Sorbet's type system.
 
 - **Result Type**
-  Model success/failure outcomes with explicit types—no more “return false or nil” for errors!
+  Model success/failure outcomes with explicit types—no more "return false or nil" for errors!
 
 - **Enums (ADTs)**
   Define your own sealed enums with typed variants. Each variant can hold distinct inner data.
-
 - **Functional Patterns**
   Chain transformations or short-circuit error handling with a clean monadic style.
 
@@ -33,17 +32,17 @@ bundle add mangrove
 
 ## Usage Overview
 
-Mangrove revolves around **`Result`** and a sealed “Enum” mechanism for ADTs.
+Mangrove revolves around **`Result`** and a sealed "Enum" mechanism for ADTs.
 
 ### Result
 
 A `Result` is either `Ok(T)` or `Err(E)`. You can compose them with monadic methods like `and_then` and `or_else`.
-For “early returns” in a functional style, you have two main approaches:
+For "early returns" in a functional style, you have two main approaches:
 
 1. **A context-based DSL (e.g., `ctx.try!`)**
 2. **An instance method on `Result` itself, `unwrap_in(ctx)`**, which behaves similarly.
 
-Here’s an example of chaining requests and short-circuiting on error:
+Here's an example of chaining requests and short-circuiting on error:
 
 ```ruby
 class MyClient
@@ -87,6 +86,32 @@ end
 # More chaining, etc...
 ```
 
+### Extension Methods
+
+Mangrove provides convenient extension methods through `Mangrove::Result::Ext`. These methods allow you to easily wrap any value in a `Result`:
+
+```ruby
+# Include the extension in your classes
+class Object
+  include Mangrove::Result::Ext
+end
+
+# Now you can use in_ok and in_err on any object
+"success".in_ok  # => Result::Ok("success")
+"error".in_err   # => Result::Err("error")
+
+# Useful in method chains
+"hello"
+  .upcase
+  .in_ok
+  .map_ok { |s| "#{s}!" }  # => Result::Ok("HELLO!")
+
+# Error case
+"error message"
+  .in_err
+  .map_err { |e| "#{e}!" } # => Result::Err("error message!")
+```
+
 ### Enums (ADTs)
 
 Define an enum with typed variants:

data/lib/mangrove/result/ext.rb

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mangrove
+  module Result
+    module Ext
+      extend T::Sig
+
+      def in_ok
+        Mangrove::Result::Ok.new(self)
+      end
+
+      def in_err
+        Mangrove::Result::Err.new(self)
+      end
+    end
+  end
+end

data/lib/mangrove/result.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "result/control_signal"
+require_relative "result/ext"
 
 module Mangrove
   # Result is a type that represents either success (`Ok`) or failure (`Err`).

data/lib/mangrove/try_from_ext.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mangrove
+  module TryFromExt
+    extend T::Sig
+    extend T::Helpers
+
+    include Kernel
+
+    sig {
+      type_parameters(:I, :O, :E)
+        .params(
+          from: T::Class[T.type_parameter(:I)],
+          to: T::Class[T.type_parameter(:O)],
+          err: T::Class[T.type_parameter(:E)],
+          block: T.proc.params(arg: T.type_parameter(:I)).returns(Mangrove::Result[T.type_parameter(:O), T.type_parameter(:E)])
+        ).void
+    }
+    # rubocop:disable Lint/UnusedMethodArgument
+    def try_convert_from(from:, to:, err:, &block)
+      T.bind(self, T::Class[T.type_parameter(:O)])
+
+      vars = from.instance_variable_get(:@convertable_to) || {}
+      vars[self] = block
+      from.instance_variable_set(:@convertable_to, vars)
+
+      @convertable_from ||= {}
+      @convertable_from[from] = [err, block]
+
+      into_t = T.cast(self, Class)
+
+      from.define_method("try_into_#{T.must_because(into_t.name) { "name is required" }.gsub(/::|([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase}") do
+        proc = T.unsafe(self).class.ancestors.lazy.map { |klass| klass.instance_variable_get(:@convertable_to)&.[](into_t) }.find(&:itself)
+
+        proc.call(self)
+      end
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+  end
+end

data/lib/mangrove/version.rb

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

data/lib/mangrove.rb

@@ -8,6 +8,7 @@ require_relative "mangrove/option"
 require_relative "mangrove/result"
 require_relative "mangrove/enum"
 require_relative "mangrove/control_flow/control_signal"
+require_relative "mangrove/try_from_ext"
 
 # Mangrove
 module Mangrove; end

data/lib/tapioca/dsl/compilers/mangrove_result_ext.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "mangrove/result/ext"
+require "tapioca/dsl"
+require "sorbet-runtime"
+
+module Tapioca
+  module Compilers
+    class MangroveResultExt < Tapioca::Dsl::Compiler
+      extend T::Sig
+
+      ConstantType = type_member { { fixed: T.class_of(Mangrove::Result::Ext) } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        all_classes.select { |c| c < ::Mangrove::Result::Ext }
+      end
+
+      sig { override.void }
+      def decorate
+        return unless valid_constant_name?(constant.to_s)
+
+        root.create_path(constant) do |klass|
+          klass.create_method("in_ok", return_type: "Mangrove::Result::Ok[#{constant}]")
+          klass.create_method("in_err", return_type: "Mangrove::Result::Err[#{constant}]")
+        end
+      rescue NameError
+        # 握りつぶす
+      end
+
+      private
+
+      sig { params(string: String).returns(T::Boolean) }
+      def valid_constant_name?(string)
+        Object.const_defined?(string) && !!(string =~ /\A[A-Z][a-zA-Z0-9_]*\z/)
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/mangrove_try_from_ext.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+require "mangrove/try_from_ext"
+require "tapioca/dsl"
+require "sorbet-runtime"
+
+module Tapioca
+  module Compilers
+    class TryFromExt < Tapioca::Dsl::Compiler
+      extend T::Sig
+
+      ConstantType = type_member { { fixed: T.class_of(Mangrove::TryFromExt) } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        all_classes.select { |c| c.singleton_class < ::Mangrove::TryFromExt }
+      end
+
+      sig { override.void }
+      def decorate
+        return if constant.instance_variable_get(:@convertable_from).nil? || constant.instance_variable_get(:@convertable_from).empty?
+
+        constant.instance_variable_get(:@convertable_from)&.each do |convertable_from, values|
+          err_constant, _block = values
+          root.create_path(convertable_from) do |klass|
+            klass.create_method("try_into_#{constant.to_s.gsub(/::|([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase}", return_type: "Mangrove::Result[#{constant}, #{err_constant}]")
+          end
+        end
+      end
+    end
+  end
+end

data/sorbet/rbi/dsl/.gitattributes

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mangrove
 version: !ruby/object:Gem::Version
-  version: 0.34.0
+  version: 0.36.0
 platform: ruby
 authors:
 - Kazuma Murata
 bindir: exe
 cert_chain: []
-date: 2025-01-21 00:00:00.000000000 Z
+date: 2025-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -46,13 +46,18 @@ files:
 - lib/mangrove/option/control_signal.rb
 - lib/mangrove/result.rb
 - lib/mangrove/result/control_signal.rb
+- lib/mangrove/result/ext.rb
+- lib/mangrove/try_from_ext.rb
 - lib/mangrove/version.rb
 - lib/tapioca/dsl/compilers/mangrove_enum.rb
+- lib/tapioca/dsl/compilers/mangrove_result_ext.rb
+- lib/tapioca/dsl/compilers/mangrove_try_from_ext.rb
 - rbi/mangrove.rbi
 - sig/mangrove.rbs
 - sorbet/config
 - sorbet/rbi/annotations/.gitattributes
 - sorbet/rbi/annotations/rainbow.rbi
+- sorbet/rbi/dsl/.gitattributes
 - sorbet/rbi/gems/.gitattributes
 - sorbet/rbi/gems/ast@2.4.2.rbi
 - sorbet/rbi/gems/benchmark@0.4.0.rbi