functional-light-service 6.2.0 → 6.3.0

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

@@ -1,155 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require_relative '../monad_axioms'
-require_relative 'result_shared'
-
-describe FunctionalLightService::Result::Success do
-  include FunctionalLightService::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

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