mangrove 0.35.0 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b672fc8a3a469a1d00a066bbc9781acbfd0229e5acf40f4d05452a3db9bd6ff2
-  data.tar.gz: 1fd9cdd284c43bbceb6b0bc44d21f358cc85d9fef1a5a3d6e9244529aa072279
+  metadata.gz: 9ba4dabf108cca13f77412fa1227a4227a02863d6eafc9d2dc4ef4a50260d537
+  data.tar.gz: 5226eff5e4088e2ec1756cf63de533e33ae57b7b57c651ffdc838777caabff04
 SHA512:
-  metadata.gz: c85f28b501f523e3d541a19a64cc560f252ce72479e1df036b75c09dfec4d43843169a614922ce1aece40867434cd5b471aaa2e4eb37337f8694f38971dc491f
-  data.tar.gz: a806cd4beb648c60e7e5ceed320ca63d0e9033b7d940fc14fbd0a3254b44b2a657704cf5ee82097aad991b11d7bf0285f99fa0bbe1946ecb5492e6f49f76fe1b
+  metadata.gz: 714d9322edd6cc20354b271f1659e0b623b8ecf1336137b493bb501ed4d884115aeee98bbc83a18f1bdad678cf3842a02ae9df09b3975b4bc9c2c169230d3b5f
+  data.tar.gz: e939ae71645f893fe28e93364978081508f7b2ae73dc86eb168b46a7e28d87b4100a5245eaf3d1af6ce96fee6b42fb024c695b113bea8a6edd47b516acab2b58

data/.rubocop.yml

@@ -31,6 +31,9 @@ Metrics/ModuleLength:
 Naming/BlockForwarding:
   EnforcedStyle: explicit
 
+Naming/MethodParameterName:
+  Enabled: false
+
 Naming/VariableNumber:
   EnforcedStyle: snake_case
 
@@ -64,3 +67,4 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
+

data/README.md

@@ -17,7 +17,6 @@ Mangrove is a Ruby toolkit that brings a functional, statically-typed flavor to
 
 - **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.
 

data/lib/mangrove/enum.rb

@@ -51,6 +51,35 @@ module Mangrove
                 T.cast(self, \#{caller.send(:binding).receiver.name})
               end
 
+              def serialize(inner_serialization_methods: [:serialize, :to_h])
+                serialized_inner = begin
+                  serialized_klass = [
+                    Hash,
+                    String,
+                    Numeric,
+                    TrueClass,
+                    FalseClass,
+                    NilClass
+                  ]
+
+                  if serialized_klass.any? { |klass| @inner.is_a?(klass) }
+                    @inner
+                  else
+                    inner_serialization_methods.find do |method_name|
+                      if @inner.respond_to?(method_name, true)
+                        maybe_hash = @inner.send(method_name)
+
+                        if maybe_hash.is_a?(Hash)
+                          break maybe_hash
+                        end
+                      end
+                    end
+                  end
+                end
+
+                { type: self.class.name, value: serialized_inner }
+              end
+
               def ==(other)
                 other.is_a?(self.class) && other.inner == @inner
               end
@@ -93,6 +122,17 @@ module Mangrove
         extend T::Helpers
 
         abstract!
+
+        def self.deserialize(hash)
+          klass = const_get(hash[:type] || hash["type"])
+          value = hash[:value] || hash["value"]
+
+          begin
+            klass.new(value)
+          rescue TypeError
+            klass.new(klass.deserialize(value))
+          end
+        end
       RUBY
 
       receiver.class_eval(code)

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.35.0"
+  VERSION = "0.37.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_enum.rb

@@ -40,6 +40,7 @@ module Tapioca
             inner_type = runtime_type_to_type_name(variant.instance_variable_get(:@__mangrove__enum_inner_type))
             constant_type.create_class(variant.name.gsub(/.*::/, ""), superclass_name: constant_type.fully_qualified_name) { |variant_type|
               variant_type.create_method("initialize", parameters: [create_param("inner", type: inner_type)], return_type: "void")
+              variant_type.create_method("serialize", parameters: [create_param("inner_serialization_methods", type: "T.nilable(T::Array[Symbol])")], return_type: "T::Hash[Symbol, T.untyped]")
               variant_type.create_method("inner", return_type: inner_type)
               variant_type.create_method("as_super", return_type: constant.name.to_s)
               variant_type.sort_nodes!
@@ -55,6 +56,8 @@ module Tapioca
                         end
 
           constant_type.create_method("inner", return_type:)
+          constant_type.create_method("serialize", parameters: [create_param("inner_serialization_methods", type: "T.nilable(T::Array[Symbol])")], return_type: "T::Hash[Symbol, T.untyped]")
+          constant_type.create_method("deserialize", parameters: [create_param("hash", type: "T::Hash[T.any(Symbol, String), T.untyped]")], return_type: constant.name)
           constant_type.create_method("as_super", return_type: constant.name.to_s)
           constant_type.sort_nodes!
         }

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.35.0
+  version: 0.37.0
 platform: ruby
 authors:
 - Kazuma Murata
 bindir: exe
 cert_chain: []
-date: 2025-01-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -47,14 +47,17 @@ files:
 - 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
@@ -132,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Toolkit for leveraging Sorbet's type system.
 test_files: []