functional-light-service 0.5.4 → 6.0.0

data/spec/lib/deterministic/result/result_map_spec.rb

@@ -1,154 +1,155 @@
-require 'spec_helper'
-
-describe FunctionalLightService::Result do
-  include FunctionalLightService::Prelude::Result
-
-  context ">> (map)" do
-    specify { expect(Success(0).map { |n| Success(n + 1) }).to eq Success(1) }
-    specify { expect(Failure(0).map { |n| Success(n + 1) }).to eq Failure(0) }
-
-    it "Failure stops execution" do
-      class ChainUnderTest
-        include FunctionalLightService::Prelude::Result
-        alias :m :method
-
-        def call
-          init >>
-            m(:validate) >>
-            m(:send) >>
-            m(:parse)
-        end
-
-        def init
-          Success(:step => 1)
-        end
-
-        def validate(i)
-          i[:step] = i[:step] + 1
-          Success(i)
-        end
-
-        def send(i)
-          i[:step] = i[:step] + 1
-          Failure("Error @ #{i.fetch(:step)}")
-        end
-
-        def parse(i)
-          i[:step] = i[:step] + 1
-          Success(i)
-        end
-      end
-
-      test = ChainUnderTest.new
-
-      expect(test.call).to eq Failure("Error @ 3")
-    end
-
-    it "expects an Result" do
-      def returns_non_result(_i)
-        2
-      end
-
-      expect { Success(1) >> method(:returns_non_result) }.to \
-        raise_error(FunctionalLightService::Monad::NotMonadError)
-    end
-
-    it "works with a block" do
-      expect(
-        Success(1).map { |i| Success(i + 1) }
-      ).to eq Success(2)
-    end
-
-    it "works with a lambda" do
-      expect(
-        Success(1) >> ->(i) { Success(i + 1) }
-      ).to eq Success(2)
-    end
-
-    it "does not catch exceptions" do
-      expect do
-        Success(1) >> ->(_i) { raise "error" }
-      end.to raise_error(RuntimeError)
-    end
-  end
-
-  context "using self as the context for success" do
-    class SelfContextUnderTest
-      include FunctionalLightService::Prelude::Result
-
-      def call
-        @step = 0
-        Success(self)
-          .map(&:validate)
-          .map(&:build)
-          .map(&:send)
-      end
-
-      def validate
-        @step = 1
-        Success(self)
-      end
-
-      def build
-        @step = 2
-        Success(self)
-      end
-
-      def send
-        @step = 3
-        Success(self)
-      end
-
-      def inspect
-        "Step #{@step}"
-      end
-
-      # # def self.procify(*meths)
-      # #   meths.each do |m|
-      # #     new_m = "__#{m}__procified".to_sym
-      # #     alias new_m m
-      # #     define_method new_m do |ctx|
-      # #       method(m)
-      # #     end
-      # #   end
-      # # end
-
-      # procify :send
-    end
-
-    it "works" do
-      test = SelfContextUnderTest.new.call
-      expect(test).to be_a described_class::Success
-      expect(test.inspect).to eq "Success(Step 3)"
-    end
-  end
-
-  context "<< (pipe)" do
-    it "ignores the output of pipe" do
-      acc = "ctx: "
-      log = ->(ctx) { acc += ctx.inspect }
-
-      actual = Success(1).pipe(log).map { Success(2) }
-      expect(actual).to eq Success(2)
-      expect(acc).to eq "ctx: Success(1)"
-    end
-
-    it "works with <<" do
-      log = ->(n) { n.value + 1 }
-      foo = ->(n) { Success(n + 1) }
-
-      Success(1) << log >> foo
-    end
-  end
-
-  context ">= (try)" do
-    it "try (>=) catches errors and wraps them as Failure" do
-      def error(ctx)
-        raise "error #{ctx}"
-      end
-
-      actual = Success(1) >= method(:error)
-      expect(actual.inspect).to eq "Failure(#<RuntimeError: error 1>)"
-    end
-  end
-end
+require 'spec_helper'
+
+describe FunctionalLightService::Result do
+  include FunctionalLightService::Prelude::Result
+
+  context ">> (map)" do
+    specify { expect(Success(0).map { |n| Success(n + 1) }).to eq Success(1) }
+    specify { expect(Failure(0).map { |n| Success(n + 1) }).to eq Failure(0) }
+
+    it "Failure stops execution" do
+      class ChainUnderTest
+        include FunctionalLightService::Prelude::Result
+
+        alias :m :method
+
+        def call
+          init >>
+            m(:validate) >>
+            m(:send) >>
+            m(:parse)
+        end
+
+        def init
+          Success(:step => 1)
+        end
+
+        def validate(i)
+          i[:step] = i[:step] + 1
+          Success(i)
+        end
+
+        def send(i)
+          i[:step] = i[:step] + 1
+          Failure("Error @ #{i.fetch(:step)}")
+        end
+
+        def parse(i)
+          i[:step] = i[:step] + 1
+          Success(i)
+        end
+      end
+
+      test = ChainUnderTest.new
+
+      expect(test.call).to eq Failure("Error @ 3")
+    end
+
+    it "expects an Result" do
+      def returns_non_result(_i)
+        2
+      end
+
+      expect { Success(1) >> method(:returns_non_result) }.to \
+        raise_error(FunctionalLightService::Monad::NotMonadError)
+    end
+
+    it "works with a block" do
+      expect(
+        Success(1).map { |i| Success(i + 1) }
+      ).to eq Success(2)
+    end
+
+    it "works with a lambda" do
+      expect(
+        Success(1) >> ->(i) { Success(i + 1) }
+      ).to eq Success(2)
+    end
+
+    it "does not catch exceptions" do
+      expect do
+        Success(1) >> ->(_i) { raise "error" }
+      end.to raise_error(RuntimeError)
+    end
+  end
+
+  context "using self as the context for success" do
+    class SelfContextUnderTest
+      include FunctionalLightService::Prelude::Result
+
+      def call
+        @step = 0
+        Success(self)
+          .map(&:validate)
+          .map(&:build)
+          .map(&:send)
+      end
+
+      def validate
+        @step = 1
+        Success(self)
+      end
+
+      def build
+        @step = 2
+        Success(self)
+      end
+
+      def send
+        @step = 3
+        Success(self)
+      end
+
+      def inspect
+        "Step #{@step}"
+      end
+
+      # # def self.procify(*meths)
+      # #   meths.each do |m|
+      # #     new_m = "__#{m}__procified".to_sym
+      # #     alias new_m m
+      # #     define_method new_m do |ctx|
+      # #       method(m)
+      # #     end
+      # #   end
+      # # end
+
+      # procify :send
+    end
+
+    it "works" do
+      test = SelfContextUnderTest.new.call
+      expect(test).to be_a described_class::Success
+      expect(test.inspect).to eq "Success(Step 3)"
+    end
+  end
+
+  context "<< (pipe)" do
+    it "ignores the output of pipe" do
+      acc = "ctx: "
+      log = ->(ctx) { acc += ctx.inspect }
+
+      actual = Success(1).pipe(log).map { Success(2) }
+      expect(actual).to eq Success(2)
+      expect(acc).to eq "ctx: Success(1)"
+    end
+
+    it "works with <<" do
+      log = ->(n) { n.value + 1 }
+      foo = ->(n) { Success(n + 1) }
+
+      Success(1) << log >> foo
+    end
+  end
+
+  context ">= (try)" do
+    it "try (>=) catches errors and wraps them as Failure" do
+      def error(ctx)
+        raise "error #{ctx}"
+      end
+
+      actual = Success(1) >= method(:error)
+      expect(actual.inspect).to eq "Failure(#<RuntimeError: error 1>)"
+    end
+  end
+end

data/spec/lib/deterministic/result/result_shared.rb

@@ -13,12 +13,13 @@ shared_examples 'Result' do
 
   it "#to_s" do
     expect(result.new(1).to_s).to eq "1"
-    expect(result.new(:a => 1).to_s).to eq "{:a=>1}"
+    # il formato di Hash#to_s/inspect cambia tra Ruby 3.3 e 3.4: costruiamo l'atteso dinamicamente
+    expect(result.new(:a => 1).to_s).to eq({ :a => 1 }.to_s)
   end
 
   it "#inspect" do
     expect(result.new(1).inspect).to eq "#{result_name}(1)"
-    expect(result.new(:a => 1).inspect).to eq "#{result_name}({:a=>1})"
+    expect(result.new(:a => 1).inspect).to eq "#{result_name}(#{{ :a => 1 }.inspect})"
   end
 end
 

data/spec/lib/deterministic/result_spec.rb

@@ -4,8 +4,8 @@ describe FunctionalLightService::Result do
   include FunctionalLightService::Prelude::Result
 
   it "can't call Result#new directly" do
-    msg = "private method `new' called for FunctionalLightService::Result:Class"
-    expect { described_class.new(1) }.to raise_error(NoMethodError, msg)
+    # il formato del messaggio NoMethodError cambia tra le versioni di Ruby
+    expect { described_class.new(1) }.to raise_error(NoMethodError, /private method [`']new'/)
   end
 
   it "fmap" do

data/spec/lib/edge_cases_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require 'functional-light-service/functional/maybe'
+
+# Copertura dei path d'errore e delle API minori emersi dall'audit
+describe "edge cases and error paths" do
+  include FunctionalLightService::Prelude::Result
+  include FunctionalLightService::Prelude::Option
+
+  describe FunctionalLightService::Context do
+    it "#add_to_context merges values" do
+      ctx = FunctionalLightService::Context.make(:a => 1)
+      ctx.add_to_context(:b => 2)
+
+      expect(ctx[:b]).to eq(2)
+    end
+  end
+
+  describe FunctionalLightService::Context::KeyVerifier do
+    it "the base verifier requires throw_error_predicate to be overridden" do
+      ctx = FunctionalLightService::Context.make
+      verifier = described_class.new(ctx, nil)
+
+      expect { verifier.throw_error_predicate([]) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "Object monkey patch (opt-in via functional/maybe)" do
+    it "defines null? and some? on every object" do
+      expect("anything".null?).to be(false)
+      expect("anything".some?).to be(true)
+    end
+  end
+
+  describe Null do
+    it "class-level unknown messages return the singleton" do
+      expect(Null.anything_at_all).to eq(Null.instance)
+    end
+
+    it "class-level respond_to? is permissive" do
+      expect(Null.respond_to?(:anything_at_all)).to be(true)
+    end
+
+    it "compares equal to another Null" do
+      expect(Null.instance == Null.instance).to be(true) # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      expect(Null.instance == "not null").to be(false)
+    end
+
+    it "a mimic only responds to the mimicked interface" do
+      klass = Class.new { def foo; end }
+      mimic = Null.mimic(klass)
+
+      expect(mimic.respond_to?(:foo)).to be(true)
+      expect(mimic.respond_to?(:bar)).to be(false)
+      expect { mimic.bar }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "enum error paths" do
+    it "raises when a variant is defined twice" do
+      expect do
+        FunctionalLightService.enum do
+          Dup()
+          Dup()
+        end
+      end.to raise_error(ArgumentError, /already defined/)
+    end
+
+    it "the enum builder responds to any variant name" do
+      builder = FunctionalLightService::EnumBuilder.new(Class.new)
+
+      expect(builder.respond_to?(:AnyVariantName)).to be(true)
+    end
+
+    it "raises MatchError when the match is not exhaustive" do
+      expect do
+        Some(1).match do
+          Some() { |s| s }
+        end
+      end.to raise_error(FunctionalLightService::Enum::MatchError, /non-exhaustive/)
+    end
+
+    it "raises MatchError when the block arity does not match the variant" do
+      expect do
+        Some(1).match do
+          Some() { |a, b| [a, b] }
+          None() { nil }
+        end
+      end.to raise_error(FunctionalLightService::Enum::MatchError, /must match/)
+    end
+
+    it "raises MatchError when no guard matches" do
+      expect do
+        Some(1).match do
+          Some(where { s > 100 }) { |s| s }
+          None() { nil }
+        end
+      end.to raise_error(FunctionalLightService::Enum::MatchError, /No match could be made/)
+    end
+
+    it "rejects unnamed/rest block parameters" do
+      # su Ruby 3.1 |*| appare come [[:rest]] (ramo "Unnamed param"),
+      # da Ruby 3.2 come [[:rest, :*]] (ramo "Only :req & :opt")
+      expect do
+        Some(1).match do
+          Some() { |*| nil }
+          None() { nil }
+        end
+      end.to raise_error(ArgumentError, /Unnamed param|Only :req & :opt/)
+    end
+
+    it "rejects keyword block parameters" do
+      expect do
+        Some(1).match do
+          Some() { |**opts| opts }
+          None() { nil }
+        end
+      end.to raise_error(ArgumentError, /Only :req & :opt params allowed/)
+    end
+
+    it "None deconstructs to an empty hash and array" do
+      none = FunctionalLightService::Option::None.new
+
+      expect(none.deconstruct).to eq([])
+      expect(none.deconstruct_keys(nil)).to eq({})
+    end
+  end
+
+  describe "Option minor APIs" do
+    it "#value_to_a returns the raw value" do
+      expect(Some(1).value_to_a).to eq(1)
+      expect(FunctionalLightService::Option::None.new.value_to_a).to be_nil
+    end
+
+    it "Prelude None() builds the shared None" do
+      expect(None().none?).to be(true)
+    end
+
+    it "Prelude Option() returns the Option enum" do
+      expect(Option()).to eq(FunctionalLightService::Option)
+    end
+  end
+
+  describe "Result minor APIs" do
+    it "#+ raises NotMonadError for non-Result operands" do
+      expect { Success(1) + "not a result" } # rubocop:disable Style/StringConcatenation
+        .to raise_error(FunctionalLightService::Monad::NotMonadError)
+    end
+
+    it "Prelude try! wraps exceptions in Failure" do
+      result = try! { raise "boom" }
+
+      expect(result).to be_failure
+      expect(result.value).to be_a(RuntimeError)
+    end
+  end
+end

data/spec/lib/enum_spec.rb

@@ -20,7 +20,7 @@ describe FunctionalLightService::Enum do
 
     it "can't instantiate parent" do
       expect { MyEnym.new }.to \
-        raise_error NoMethodError, "private method `new' called for MyEnym:Class"
+        raise_error NoMethodError, /private method [`']new'/
     end
 
     it "Nullary" do

data/spec/lib/native_pattern_matching_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe "native Ruby pattern matching (case/in) support" do
+  include FunctionalLightService::Prelude::Result
+  include FunctionalLightService::Prelude::Option
+
+  Result = FunctionalLightService::Result
+  Option = FunctionalLightService::Option
+
+  it "deconstructs Success/Failure positionally" do
+    matched =
+      case Success(42)
+      in Result::Success[value] then "success: #{value}"
+      in Result::Failure[error] then "failure: #{error}"
+      end
+
+    expect(matched).to eq("success: 42")
+  end
+
+  it "deconstructs Failure positionally" do
+    matched =
+      case Failure(:boom)
+      in Result::Success[value] then "success: #{value}"
+      in Result::Failure[error] then "failure: #{error}"
+      end
+
+    expect(matched).to eq("failure: boom")
+  end
+
+  it "deconstructs by keys using the variant's field names" do
+    matched =
+      case Success(42)
+      in Result::Success(s:) then s
+      in Result::Failure(f:) then f
+      end
+
+    expect(matched).to eq(42)
+  end
+
+  it "deconstructs Some and None" do
+    some_result =
+      case Some(7)
+      in Option::Some[v] then v
+      in Option::None then :none
+      end
+    none_result =
+      case None()
+      in Option::Some[v] then v
+      in Option::None then :none
+      end
+
+    expect(some_result).to eq(7)
+    expect(none_result).to eq(:none)
+  end
+
+  Shape = FunctionalLightService.enum do
+    Point(:x, :y)
+    Origin()
+  end
+
+  it "deconstructs multi-field (Binary) variants by keys" do
+    matched =
+      case Shape::Point.new(1, 2)
+      in Shape::Point(x:, y:) then [x, y]
+      in Shape::Origin then [0, 0]
+      end
+
+    expect(matched).to eq([1, 2])
+  end
+
+  def None # rubocop:disable Naming/MethodName
+    FunctionalLightService::Option::None.new
+  end
+end