deterministic 0.8.1 → 0.10.0

data/spec/lib/deterministic/attempt_all_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-include Deterministic
-
-describe Deterministic::Either::AttemptAll do
-  it "#try evaluates the result as Success" do
-    expect(
-      Either.attempt_all do
-        try { @a = 1 }
-        try { @b = @a + 1 }
-      end
-    ).to eq Success(2)
-  end
-
-  it "#try values are passed to the next command" do
-    expect(
-      Either.attempt_all do
-        try { 1 }
-        try { |v| v + 1 }
-      end
-    ).to eq Success(2)
-  end
-
-  it "try treat exceptions as Failure" do
-    attempt = Either.attempt_all do
-      try { 1 }
-      try { raise "error" }
-    end.value
-    expect(attempt).to be_a RuntimeError
-    expect(attempt.message).to eq "error"
-  end
-
-  it "don't continue on failure" do
-    fake = double()
-    expect(
-      Either.attempt_all do
-        try { 1 }
-        let { Failure(2) }
-        try { fake.should_not_be_called }
-      end
-    ).to eq Failure(2)
-  end
-
-  it "#let expects Success or Failure" do
-    expect(
-      Either.attempt_all do
-        let { Success(1) }
-      end
-    ).to eq Success(1)
-
-    expect {
-      Either.attempt_all do
-        let { 1 }
-      end
-    }.to raise_error(Deterministic::Either::AttemptAll::EitherExpectedError)
-  end
-
-  it "#let will not catch errors" do
-    expect {
-      Either.attempt_all do
-        let { raise "error" }
-      end
-    }.to raise_error
-  end
-
-  it "#let passes params unboxed" do
-    expect(
-      Either.attempt_all do
-        try { 1 }
-        let { |v| Success(v + 1) }
-      end
-    ).to eq Success(2)
-  end
-
-
-  it "works with boxed values" do
-    expect(
-      Either.attempt_all do
-        try { Failure(1) }
-        try { 2 }
-      end
-    ).to eq Failure(1)
-  end
-
-  it "works with an OpenStruct" do
-    context = OpenStruct.new
-    attempt = Either.attempt_all(context) do
-      let { Success(self.alpha = 2) }
-      try { self.res = 1 }
-    end
-
-    expect(context.res).to eq 1
-    expect(context.alpha).to eq 2
-  end
-
-  it "can operate in the context of a context" do
-    class Context
-      attr_accessor :a
-      def initialize
-        @a = 1
-      end
-    end
-
-    context = Context.new
-
-    expect(
-      Either.attempt_all(context) do
-        try { self.a += 1 }
-        try { self.a + 1 }
-      end
-    ).to eq Success(3)
-
-    expect(context.a).to eq 2
-  end
-end

data/spec/lib/deterministic/core_ext/either_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-require "deterministic"
-require "deterministic/core_ext/either"
-
-describe Deterministic::CoreExt::Either do
-  it "does something" do
-    h = {}
-    h.extend(Deterministic::CoreExt::Either)
-    expect(h.success?).to be_falsey
-    expect(h.failure?).to be_falsey
-    expect(h.either?).to be_falsey
-  end
-
-  it "enables #success?, #failure?, #either? on all Objects" do
-    ary = [Deterministic::Success(true), Deterministic::Success(1)]
-    expect(ary.all?(&:success?)).to be_truthy
-
-    ary = [Deterministic::Success(true), Deterministic::Failure(1)]
-    expect(ary.all?(&:success?)).to be_falsey
-    expect(ary.any?(&:failure?)).to be_truthy
-  end
-
-  it "allows using attempt_all on all Objects" do
-    h = {a: 1}
-    h.extend(Deterministic::CoreExt::Either)
-    res = h.attempt_all do
-      try { |s| s[:a] + 1}
-    end
-
-    expect(res).to eq Deterministic::Success(2)
-  end
-
-  it "use attempt_all in an instance" do
-    class UnderTest
-      include Deterministic::CoreExt::Either
-      def test
-        attempt_all do
-          try { foo }
-        end
-      end
-
-      def foo
-        1
-      end
-    end
-
-    ut = UnderTest.new
-    expect(ut.test).to eq Success(1)
-  end
-end

data/spec/lib/deterministic/either/chain_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-include Deterministic
-
-describe Deterministic::Either do
-  context ">> (chain)" do
-    it "Failure stops execution" do
-      class ChainUnderTest
-        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 Either" do
-      def returns_non_either(i)
-        2
-      end
-
-      expect { Success(1) >> method(:returns_non_either) }.to raise_error(Deterministic::Monad::NotMonadError)
-    end
-
-    it "works with a block" do
-      expect(
-        Success(1).chain { |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 {
-        Success(1) >> ->(i) { raise "error" }
-      }.to raise_error(RuntimeError)
-    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(error 1)"
-    end
-  end
-end

data/spec/lib/deterministic/either/either_shared.rb

@@ -1,23 +0,0 @@
-shared_examples 'Either' do
-  let(:either_name) { described_class.name.split("::")[-1]}
-  specify { expect(subject.value).to eq 1 }
-  specify { expect(either.new(subject)).to eq either.new(1) }
-
-  it "#map" do
-    expect(either.new(1).map { |e| e + 1 }).to eq either.new(2)
-  end
-
-  it "#bind" do
-    expect(either.new(1).bind { |v| either.new(v + 1)}).to eq either.new(2)
-  end
-
-  it "#to_s" do
-    expect(either.new(1).to_s).to eq "1"
-    expect(either.new({a: 1}).to_s).to eq "{:a=>1}"
-  end
-
-  it "#inspect" do
-    expect(either.new(1).inspect).to eq "#{either_name}(1)"
-    expect(either.new(:a=>1).inspect).to eq "#{either_name}({:a=>1})"
-  end
-end