mangrove 0.21.2 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 614ac5851a78950c569f55d16aeba8fd0e1d30c11de41912bdd5cd71ee946a0c
-  data.tar.gz: 4a67c0db80f4b2f2e79e544edf8baa8bdb86781f12575269c2e52d7c691cbc7d
+  metadata.gz: b103efd7003a037c53a885f2ee19899ba8643770237c11bee728f06054611be7
+  data.tar.gz: 5e7557ab35bb32b8212b830ba5d06c6f32904cf2b40fd04de3f469770afb19d1
 SHA512:
-  metadata.gz: fe09a873d6d1ea23dd9708763d9bb9235176843f581309631918b1bd9a5a52b52e0c9d7948afb649aa968d1bae5538a81786695fdea1f18401bbb0f5cb9c446b
-  data.tar.gz: 7c8a24200e2a1add424b6cb2e4117bf22161cd7765c31f9588350e88b500a50485bfe6c60255d99cef8391b35e695e116a2a4725df9d1e6fa4119d49e1e4da63
+  metadata.gz: d8f487f7ccd5ce99225cb19108eed5e3f89d1fece9048bd589ad78f4179a07ce370d47a876a66e30a992661cee5f40f970e3d3544b2a53e32677d58c3a5294c1
+  data.tar.gz: 1c3003bca763ff503c496f15d271d253a8510c33bdb74ade89708c91774d31fd0c0f29b06a89de4a3661ef4b1b8fa8e863f838d42b4a89aa7e02cca189abcfed

data/.rubocop.yml

@@ -53,6 +53,9 @@ Style/IfUnlessModifier:
 Style/MultilineBlockChain:
   Enabled: false
 
+Style/RedundantConstantBase:
+  Enabled: false
+
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes

data/.vscode/settings.json

@@ -1,5 +1,6 @@
 {
   "cSpell.words": [
+    "klass",
     "ordinare",
     "ruboclean"
   ]

data/README.md

@@ -1,119 +1,17 @@
 # Mangrove
 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
-  extend T::Sig
-
-  sig { params(numbers: T::Enumerable[Integer]).returns(Mangrove::Result[T::Array[Integer], String]) }
-  def divide_arguments_by_3(numbers)
-    Mangrove::Result.from_results(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
-      })
-  rescue ::Mangrove::ControlFlow::ControlSignal => e
-    Mangrove::Result::Err.new(e.inner_value)
-  end
-end
-# rubocop:enable Lint/ConstantDefinitionInBlock
-
-expect(TransposeExample.new.divide_arguments_by_3([3, 4, 5])).to eq Mangrove::Result::Err.new(["number 4 is not divisible by 3", "number 5 is not divisible by 3"])
-expect(TransposeExample.new.divide_arguments_by_3([3, 6, 9])).to eq Mangrove::Result::Ok.new([1, 2, 3])
-
-```
-
-or like this.
-```ruby
-class MyController
-  extend T::Sig
-
-  sig { params(input: String).returns(String) }
-  def create(input)
-    result = MyService.new.execute(input)
-
-    case result
-    when Mangrove::Result::Ok
-      result.ok_inner
-    when Mangrove::Result::Err
-      error = result.err_inner
-
-      case error
-      when MyService::MyServiceError::E1
-        "e1: #{error.inner.msg}"
-      when MyService::MyServiceError::E2
-        "e2: #{error.inner.msg}"
-      when MyService::MyServiceError::Other
-        "other: #{error.inner.msg}"
-      else T.absurd(error)
-      end
-    end
-  end
-end
+Mangrove is a Ruby Gem designed to be the definitive toolkit for leveraging Sorbet's type system in Ruby applications. It's designed to offer a robust, statically-typed experience, focusing on solid types, a functional programming style, and an interface-driven approach.
 
-class MyService
-  extend T::Sig
-  extend T::Generic
+Use `rubocop-mangrove` to statically check rescuing ControlSignal is done
 
-  include Kernel
-
-  E = type_member { { upper: MyServiceError } }
-
-  sig { params(input: String).returns(Mangrove::Result[String, MyServiceError]) }
-  def execute(input)
-    input
-      .safe_to_i
-      .map_err_wt(MyServiceError::Other) { |e|
-        MyServiceError::Other.new(MyAppError::Other.new(e)).as_my_service_error
-      }.and_then_wt(String) { |num|
-        if num < 1
-          Mangrove::Result.err(String, MyServiceError::E1.new(MyAppError::E1.new("num < 1")).as_my_service_error)
-        elsif num < 3
-          Mangrove::Result
-            .ok(num, String)
-            .and_then_wt(String) { |n|
-              if n < 2
-                Mangrove::Result.ok("`#{n}` < 2", String)
-              else
-                Mangrove::Result.err(String, "not `#{n}` < 2")
-              end
-            }
-            .map_err_wt(MyServiceError::E1) { |e|
-              MyServiceError::E1.new(MyAppError::E1.new("mapping to E1 #{e}")).as_my_service_error
-            }
-            .map_ok { |str|
-              {
-                my_key: str
-              }
-            }
-            .map_ok(&:to_s)
-        else
-          Mangrove::Result.err(String, MyServiceError::E2.new(MyAppError::E2.new).as_my_service_error)
-        end
-      }
-  end
-end
-
-expect(MyController.new.create("0")).to eq "e1: num < 1"
-expect(MyController.new.create("1")).to eq "{:my_key=>\"`1` < 2\"}"
-expect(MyController.new.create("2")).to eq "e1: mapping to E1 not `2` < 2"
-expect(MyController.new.create("3")).to eq "e2: e2"
-expect(MyController.new.create("invalid")).to eq "other: invalid value for Integer(): \"invalid\""
-```
-
-Other examples are available at [`spec/**/**_spec.rb`](https://github.com/kazzix14/mangrove/tree/main/spec).
+- [Documentation](https://kazzix14.github.io/mangrove/docs/)
+- [Coverage](https://kazzix14.github.io/mangrove/coverage/index.html#_AllFiles)
 
 ## Features
 - Option Type
 - Result Type
+- Enums with inner types (ADTs)
 
 ## Installation
 
@@ -152,19 +50,10 @@ bundle exec tapioca init
 bundle exec rspec -f d
 bundle exec rubocop -DESP
 bundle exec srb typecheck
+bundle exec spoom tc
 bundle exec ordinare --check
 bundle exec ruboclean
 bundle exec yardoc -o docs/ --plugin yard-sorbet
 rake build
 rake release
 ```
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/kazzix14/mangrove.

data/lib/mangrove/enum.rb

@@ -0,0 +1,101 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Mangrove
+  class EnumVariantsScope
+    extend ::T::Sig
+    extend ::T::Helpers
+
+    sig { params(parent: T::Class[T.anything]).void }
+    def initialize(parent)
+      @parent = parent
+    end
+
+    sig { params(block: T.proc.void).void }
+    def call(&block)
+      instance_eval(&block)
+    end
+
+    sig { params(variant: T::Class[T.anything], inner_type: T.untyped).void }
+    def variant(variant, inner_type)
+      variant.instance_variable_set(:@__mangrove__enum_inner_type, inner_type)
+    end
+  end
+  private_constant :EnumVariantsScope
+
+  module Enum
+    extend ::T::Sig
+    extend ::T::Helpers
+
+    requires_ancestor { Module }
+
+    sig { params(block: T.proc.bind(EnumVariantsScope).void).void }
+    def variants(&block)
+      receiver = block.send(:binding).receiver
+
+      outer_code = <<~RUBY
+        def self.const_missing(id)
+          code = <<~NESTED_RUBY
+            class \#{id} < \#{caller.send(:binding).receiver.name}
+              def initialize(inner)
+                @inner = T.let(inner, self.class.instance_variable_get(:@__mangrove__enum_inner_type))
+              end
+
+              def inner
+                @inner
+              end
+
+              def as_super
+                T.cast(self, \#{caller.send(:binding).receiver.name})
+              end
+
+              def ==(other)
+                other.is_a?(self.class) && other.inner == @inner
+              end
+            end
+          NESTED_RUBY
+
+          class_eval(code, __FILE__, __LINE__ + 1)
+          class_eval(id.to_s, __FILE__, __LINE__ + 1)
+        end
+      RUBY
+
+      original_const_missing = receiver.method(:const_missing)
+
+      receiver.class_eval(outer_code, __FILE__, __LINE__ + 1)
+      EnumVariantsScope.new(receiver).call(&block)
+
+      # Mark as sealed hear because we can not define classes in const_missing after marking as sealed
+      receiver.send(:eval, "sealed!", nil, __FILE__, __LINE__)
+
+      variants = constants.filter_map { |variant_name|
+        maybe_variant = receiver.const_get(variant_name, false)
+
+        if maybe_variant.instance_variable_defined?(:@__mangrove__enum_inner_type)
+          maybe_variant
+        end
+      }
+
+      receiver.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        @sorbet_sealed_module_all_subclasses = #{variants} # @sorbet_sealed_module_all_subclasses = #{variants}
+      RUBY
+
+      # Bring back the original const_missing
+      receiver.define_singleton_method(:const_missing, original_const_missing)
+    end
+
+    sig { params(receiver: T::Class[T.anything]).void }
+    def self.extended(receiver)
+      code = <<~RUBY
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+      RUBY
+
+      receiver.class_eval(code)
+    end
+  end
+end

data/lib/mangrove/version.rb

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

data/lib/mangrove.rb

@@ -6,6 +6,7 @@ require "sorbet-runtime"
 require_relative "mangrove/version"
 require_relative "mangrove/option"
 require_relative "mangrove/result"
+require_relative "mangrove/enum"
 require_relative "mangrove/control_flow/control_signal"
 
 # Mangrove

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

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "mangrove"
+require "tapioca/dsl"
+
+module Tapioca
+  module Compilers
+    class MangroveEnum < Tapioca::Dsl::Compiler
+      extend T::Sig
+
+      ConstantType = type_member { { fixed: T.class_of(::Mangrove::Enum) } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        all_classes.select { |c| c.singleton_class < ::Mangrove::Enum && T::AbstractUtils.abstract_module?(c) }
+      end
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant) { |constant_type|
+          constant_type.nodes.append(
+            RBI::Helper.new("abstract"),
+            RBI::Helper.new("sealed")
+          )
+
+          variants = constant.constants.filter_map { |variant_name|
+            maybe_variant = constant.const_get(variant_name, false)
+
+            if maybe_variant.instance_variable_defined?(:@__mangrove__enum_inner_type)
+              maybe_variant
+            end
+          }
+
+          inner_types = variants.map { |variant|
+            inner_type = variant.instance_variable_get(:@__mangrove__enum_inner_type).to_s
+            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("inner", return_type: inner_type)
+              variant_type.create_method("as_super", return_type: constant.name.to_s)
+            }
+
+            inner_type
+          }
+
+          constant_type.create_method("inner", return_type: "T.any(#{inner_types.join(", ")})")
+          constant_type.create_method("as_super", return_type: constant.name.to_s)
+        }
+      end
+    end
+  end
+end