switchyard 7.0.0

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require_relative '../monad_axioms'
+require_relative 'result_shared'
+
+describe Switchyard::Result::Failure do
+  include Switchyard::Prelude::Result
+
+  it_behaves_like 'a Monad' do
+    let(:monad) { described_class }
+  end
+
+  subject { described_class.new(1) }
+
+  specify { expect(subject).to be_an_instance_of described_class }
+  specify { expect(subject).to be_failure }
+  specify { expect(subject).not_to be_success }
+  specify { expect(subject.success?).to be_falsey }
+  specify { expect(subject.failure?).to be_truthy }
+
+  specify { expect(subject).to be_an_instance_of described_class }
+  specify { expect(subject).to eq(described_class.new(1)) }
+  specify { expect(subject.fmap { |v| v + 1 }).to eq Failure(2) }
+  specify { expect(subject.map { |v| Success(v + 1) }).to eq Failure(1) }
+  specify { expect(subject.map_err { |v| Success(v + 1) }).to eq Success(2) }
+  specify do
+    expect(subject.pipe { |v| raise RuntimeError unless v == Failure(1) }).to eq Failure(1)
+  end
+
+  specify { expect(subject.or(Success(2))).to eq Success(2) }
+  specify { expect(subject.or(Failure(2))).to eq Failure(2) }
+  specify { expect(subject.or_else { Success(2) }).to eq Success(2) }
+  specify { expect(subject.or_else { Failure(2) }).to eq Failure(2) }
+
+  specify { expect(subject.and(Success(2))).to eq Failure(1) }
+  specify { expect(subject.and_then { Success(2) }).to eq Failure(1) }
+
+  it_behaves_like 'Result' do
+    let(:result) { described_class }
+  end
+
+  it "#or" do
+    expect(Success(1).or(Failure(2))).to eq Success(1)
+    expect(Failure(1).or(Success(2))).to eq Success(2)
+    expect { Failure(1).or(2) }.to raise_error(Switchyard::Monad::NotMonadError)
+  end
+
+  it "#or_else" do
+    expect(Success(1).or_else { Failure(2) }).to eq Success(1)
+    expect(Failure(1).or_else { |v| Success(v + 1) }).to eq Success(2)
+    expect { Failure(1).or_else { 2 } }.to raise_error(Switchyard::Monad::NotMonadError)
+  end
+
+  it "#and" do
+    expect(Success(1).and(Success(2))).to eq Success(2)
+    expect(Failure(1).and(Success(2))).to eq Failure(1)
+    expect { Success(1).and(2) }.to raise_error(Switchyard::Monad::NotMonadError)
+  end
+
+  it "#and_then" do
+    expect(Success(1).and_then { Success(2) }).to eq Success(2)
+    expect(Failure(1).and_then { Success(2) }).to eq Failure(1)
+    expect { Success(1).and_then { 2 } }.to \
+      raise_error(Switchyard::Monad::NotMonadError)
+  end
+end

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

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Switchyard::Result do
+  include Switchyard::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 Switchyard::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(Switchyard::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 Switchyard::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

@@ -0,0 +1,25 @@
+shared_examples 'Result' do
+  let(:result_name) { described_class.name.split("::")[-1] }
+  specify { expect(subject.value).to eq 1 }
+  specify { expect(result.new(subject)).to eq result.new(1) }
+
+  it "#fmap" do
+    expect(result.new(1).fmap { |e| e + 1 }).to eq result.new(2)
+  end
+
+  it "#bind" do
+    expect(result.new(1).bind { |v| result.new(v + 1) }).to eq result.new(2)
+  end
+
+  it "#to_s" do
+    expect(result.new(1).to_s).to eq "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 }.inspect})"
+  end
+end
+

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require_relative '../monad_axioms'
+require_relative 'result_shared'
+
+describe Switchyard::Result::Success do
+  include Switchyard::Prelude::Result
+
+  it_behaves_like 'a Monad' do
+    let(:monad) { described_class }
+  end
+
+  subject { described_class.new(1) }
+
+  specify { expect(subject).to be_an_instance_of described_class }
+  specify { expect(subject).to be_success }
+  specify { expect(subject).not_to be_failure }
+  specify { expect(subject.success?).to be_truthy }
+  specify { expect(subject.failure?).to be_falsey }
+
+  specify { expect(subject).to be_an_instance_of described_class }
+  specify { expect(subject).to eq(described_class.new(1)) }
+  specify { expect(subject.fmap { |v| v + 1 }).to eq Success(2) }
+  specify { expect(subject.map { |v| Failure(v + 1) }).to eq Failure(2) }
+  specify { expect(subject.map_err { |v| Failure(v + 1) }).to eq Success(1) }
+
+  specify do
+    expect(subject.pipe { |r| raise RuntimeError unless r == Success(1) }).to eq Success(1)
+  end
+
+  specify { expect(subject.or(Success(2))).to eq Success(1) }
+  specify { expect(subject.or_else { Success(2) }).to eq Success(1) }
+
+  specify { expect(subject.and(Success(2))).to eq Success(2) }
+  specify { expect(subject.and(Failure(2))).to eq Failure(2) }
+  specify { expect(subject.and_then { Success(2) }).to eq Success(2) }
+  specify { expect(subject.and_then { Failure(2) }).to eq Failure(2) }
+
+  it_behaves_like 'Result' do
+    let(:result) { described_class }
+  end
+end

data/spec/lib/deterministic/result_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Switchyard::Result do
+  include Switchyard::Prelude::Result
+
+  it "can't call Result#new directly" do
+    # 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
+    expect(Success(1).fmap { |n| n + 1 }).to eq Success(2)
+    expect(Failure(0).fmap { |n| n + 1 }).to eq Failure(1)
+  end
+
+  it "map" do
+    expect(Success(1).map { |n| Success(n + 1) }).to eq Success(2)
+    expect(Failure(0).map { |n| Success(n + 1) }).to eq Failure(0)
+  end
+
+  it "+" do
+    expect(Success([1]) + Failure([2])).to eq Failure([2])
+    expect(Success(1) + Success(1)).to eq Success(2)
+    expect(Failure(2) + Success(1)).to eq Failure(2)
+    expect(Failure([2]) + Failure([3]) + Success(1)).to eq Failure([2, 3])
+    expect(Success([1]) + Success([1])).to eq Success([1, 1])
+    expect { Success([1]) + Success(1) }.to raise_error TypeError
+  end
+
+  subject { Success(1) }
+  # specify { expect(subject).to be_an_instance_of described_class }
+  specify { expect(subject).to be_success }
+  specify { expect(subject).not_to be_failure }
+  specify { expect(subject.success?).to be_truthy }
+  specify { expect(subject.failure?).to be_falsey }
+
+  specify { expect(subject).to be_a described_class }
+  # specify { expect(subject).to eq(described_class.new(1)) }
+  specify { expect(subject.fmap { |v| v + 1 }).to eq Success(2) }
+  specify { expect(subject.map { |v| Failure(v + 1) }).to eq Failure(2) }
+  specify { expect(subject.map_err { |v| Failure(v + 1) }).to eq Success(1) }
+
+  specify do
+    expect(subject.pipe do |r|
+             raise RuntimeError unless r == Success(1)
+           end).to eq Success(1)
+  end
+
+  specify { expect(subject.or(Success(2))).to eq Success(1) }
+  specify { expect(subject.or_else { Success(2) }).to eq Success(1) }
+
+  specify { expect(subject.and(Success(2))).to eq Success(2) }
+  specify { expect(subject.and(Failure(2))).to eq Failure(2) }
+  specify { expect(subject.and_then { Success(2) }).to eq Success(2) }
+  specify { expect(subject.and_then { Failure(2) }).to eq Failure(2) }
+
+  it "try!" do
+    expect(described_class.try! { 1 }).to eq Success(1)
+    expect(described_class.try! { raise "error" }.inspect).to \
+      eq Failure(RuntimeError.new("error")).inspect
+  end
+end
+