fear 1.1.0 → 1.2.0

data/spec/dry/types/fear/option/option_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, "#option", :option do
+  context "with a nominal" do
+    subject(:type) { Dry::Types["nominal.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type["hello"]).to be_some_of("hello")
+    end
+
+    it "returns original if input is already a option" do
+      expect(type[Fear.some("hello")]).to be_some_of("hello")
+    end
+
+    it "aliases #[] as #call" do
+      expect(type.("hello")).to be_some_of("hello")
+    end
+
+    it "does not have primitive" do
+      expect(type).to_not respond_to(:primitive)
+    end
+  end
+
+  context "with a strict type" do
+    subject(:type) { Dry::Types["strict.integer"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type[231]).to be_some_of(231)
+    end
+  end
+
+  context "with a sum" do
+    subject(:type) { Dry::Types["nominal.bool"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type[true]).to be_some_of(true)
+      expect(type[false]).to be_some_of(false)
+    end
+
+    it "does not have primitive" do
+      expect(type).to_not respond_to(:primitive)
+    end
+  end
+
+  context "with keys" do
+    subject(:type) do
+      Dry::Types["hash"].schema(foo: Dry::Types["integer"]).key(:foo)
+    end
+
+    it "gets wrapped by key type" do
+      expect(type.option).to be_a(Dry::Types::Schema::Key)
+      expect(type.option[nil]).to be_none
+      expect(type.option[1]).to be_some_of(1)
+    end
+  end
+
+  describe "#try" do
+    subject(:type) { Dry::Types["coercible.integer"].option }
+
+    it "maps successful result" do
+      expect(type.try("1")).to eq(Dry::Types::Result::Success.new(Fear.some(1)))
+      expect(type.try(nil)).to eq(Dry::Types::Result::Success.new(Fear.none))
+      expect(type.try("a")).to be_a(Dry::Types::Result::Failure)
+    end
+  end
+
+  describe "#call" do
+    describe "safe calls" do
+      subject(:type) { Dry::Types["coercible.integer"].option }
+
+      specify do
+        expect(type.("a") { :fallback }).to be(:fallback)
+        expect(type.(Fear.some(1)) { :fallback }).to eq(Fear.some(1))
+      end
+    end
+  end
+end

data/spec/fear/awaitable_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Awaitable do
+  subject(:awaitable) { Object.new.extend(Fear::Awaitable) }
+
+  describe "#__ready__" do
+    it "must implement the method" do
+      expect { awaitable.__ready__(1) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#__result__" do
+    it "must implement the method" do
+      expect { awaitable.__result__(1) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/fear/either_pattern_matching_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Either do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Right[Integer => int]
+        "right of #{int}"
+      in Fear::Left[Integer => int]
+        "left of #{int}"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is right of integer" do
+      let(:value) { Fear.right(42) }
+
+      it { is_expected.to eq("right of 42") }
+    end
+
+    context "when value is left of integer" do
+      let(:value) { Fear.left(42) }
+
+      it { is_expected.to eq("left of 42") }
+    end
+  end
+end

data/spec/fear/future_spec.rb

@@ -398,11 +398,20 @@ RSpec.describe Fear::Future do
     subject { Fear::Await.result(future, 1) }
 
     context "successful" do
-      let(:future) { this.zip(that) }
       let!(:this) { Fear.future { 1 } }
       let!(:that) { Fear.future { 2 } }
 
-      it { is_expected.to eq(Fear.success([1, 2])) }
+      context "without a block" do
+        let(:future) { this.zip(that) }
+
+        it { is_expected.to eq(Fear.success([1, 2])) }
+      end
+
+      context "with a block" do
+        let(:future) { this.zip(that) { |x, y| x + y } }
+
+        it { is_expected.to eq(Fear.success(3)) }
+      end
     end
 
     context "first failed" do

data/spec/fear/none_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Fear::None do
+RSpec.describe "Fear::None" do
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { Fear.none }
   end

data/spec/fear/option_pattern_matching_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Option do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Some(Integer => int)
+        "some of #{int}"
+      in Fear::None
+        "none"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is some of integer" do
+      let(:value) { Fear.some(42) }
+
+      it { is_expected.to eq("some of 42") }
+    end
+
+    context "when value is none" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
+    end
+
+    context "when value is not some of integer" do
+      let(:value) { Fear.some("42") }
+
+      it { is_expected.to eq("something else") }
+    end
+  end
+end

data/spec/fear/option_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Option do
+  describe "#zip" do
+    subject { left.zip(right) }
+
+    context "some with some" do
+      let(:left) { Fear.some(42) }
+      let(:right) { Fear.some(664) }
+
+      context "without a block" do
+        subject { left.zip(right) }
+
+        it { is_expected.to eq(Fear.some([42, 664])) }
+      end
+
+      context "with a block" do
+        subject { left.zip(right) { |x, y| x * y } }
+
+        it { is_expected.to eq(Fear.some(27_888)) }
+      end
+    end
+
+    context "some with none" do
+      let(:left) { Fear.some(42) }
+      let(:right) { Fear.none }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "none with some" do
+      let(:left) { Fear.none }
+      let(:right) { Fear.some(42) }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "none with none" do
+      let(:left) { Fear.none }
+      let(:right) { Fear.none }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+  end
+
+  describe "#filter_map" do
+    subject { option.filter_map(&filter_map) }
+
+    context "some mapped to nil" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(*) { nil } }
+
+      it { is_expected.to be_none }
+    end
+
+    context "some mapped to false" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(*) { false } }
+
+      it { is_expected.to be_none }
+    end
+
+    context "some mapped to true" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(*) { true } }
+
+      it { is_expected.to be_some_of(true) }
+    end
+
+    context "some mapped to another value" do
+      let(:option) { Fear.some(42) }
+      let(:filter_map) { ->(x) { x / 2 if x.even? } }
+
+      it { is_expected.to be_some_of(21) }
+    end
+
+    context "none" do
+      let(:option) { Fear.none }
+      let(:filter_map) { ->(x) { x / 2 } }
+
+      it { is_expected.to be_none }
+    end
+  end
+
+  describe "#matcher" do
+    subject(:result) { matcher.(value) }
+
+    let(:matcher) do
+      described_class.matcher do |m|
+        m.some { |x| "some of #{x}" }
+        m.none { "none" }
+      end
+    end
+
+    context "when matches some branch" do
+      let(:value) { Fear.some(42) }
+
+      it { is_expected.to eq("some of 42") }
+    end
+
+    context "when matches none branch" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
+    end
+  end
+
+  describe "#match" do
+    subject(:matcher) do
+      described_class.match(value) do |m|
+        m.some { |x| "some of #{x}" }
+        m.none { "none" }
+      end
+    end
+
+    context "when matches some branch" do
+      let(:value) { Fear.some(42) }
+
+      it { is_expected.to eq("some of 42") }
+    end
+
+    context "when matches none branch" do
+      let(:value) { Fear.none }
+
+      it { is_expected.to eq("none") }
+    end
+  end
+end

data/spec/fear/partial_function_spec.rb

@@ -63,6 +63,29 @@ RSpec.describe Fear::PartialFunction do
     end
   end
 
+  describe ".or" do
+    subject { described_class.or(guard_1, guard_2, &Fear::Utils::IDENTITY) }
+
+    let(:guard_1) { ->(x) { x == 42 } }
+    let(:guard_2) { ->(x) { x == 21 } }
+
+    it { is_expected.to be_defined_at(42) }
+    it { is_expected.to be_defined_at(21) }
+    it { is_expected.not_to be_defined_at(20) }
+  end
+
+  describe ".and" do
+    subject { described_class.and(guard_1, guard_2, &Fear::Utils::IDENTITY) }
+
+    let(:guard_1) { ->(x) { x % 5 == 0 } }
+    let(:guard_2) { ->(x) { x % 2 == 0 } }
+
+    it { is_expected.to be_defined_at(10) }
+    it { is_expected.not_to be_defined_at(5) }
+    it { is_expected.not_to be_defined_at(2) }
+    it { is_expected.not_to be_defined_at(3) }
+  end
+
   describe "#lift" do
     let(:lifted) { partial_function.lift }
 
@@ -186,4 +209,31 @@ RSpec.describe Fear::PartialFunction do
       it { is_expected.not_to raise_error }
     end
   end
+
+  shared_examples "#or_else" do |method_name|
+    subject { is_even.__send__(method_name, is_odd).(value) }
+
+    let(:is_even) { Fear.case(:even?.to_proc) { |x| "#{x} is even" } }
+    let(:is_odd) { Fear.case(:odd?.to_proc) { |x| "#{x} is odd" } }
+
+    context "when left side is defined" do
+      let(:value) { 42 }
+
+      it { is_expected.to eq("42 is even") }
+    end
+
+    context "when left side is not defined" do
+      let(:value) { 21 }
+
+      it { is_expected.to eq("21 is odd") }
+    end
+  end
+
+  describe "#or_else" do
+    include_examples "#or_else", :or_else
+  end
+
+  describe "#|" do
+    include_examples "#or_else", :|
+  end
 end

data/spec/fear/pattern_matching_api_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::PatternMatchingApi do
+  describe "Fear.match" do
+    subject do
+      Fear.match(value) do |m|
+        m.case(Integer, :even?.to_proc) { |x| "#{x} is even" }
+        m.case(Integer, :odd?.to_proc) { |x| "#{x} is odd" }
+        m.else { |x| "#{x} is not a number" }
+      end
+    end
+
+    context "when one branch matches" do
+      let(:value) { 42 }
+
+      it { is_expected.to eq("42 is even") }
+    end
+
+    context "when another branch matches" do
+      let(:value) { 21 }
+
+      it { is_expected.to eq("21 is odd") }
+    end
+
+    context "when else matches" do
+      let(:value) { "foo" }
+
+      it { is_expected.to eq("foo is not a number") }
+    end
+  end
+end

data/spec/fear/try_pattern_matching_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Try do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Success[Integer => int]
+        "success of #{int}"
+      in Fear::Failure[RuntimeError]
+        "runtime error"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is success of integer" do
+      let(:value) { Fear.try { 42 } }
+
+      it { is_expected.to eq("success of 42") }
+    end
+
+    context "when value is failure runtime error" do
+      let(:value) { Fear.try { raise } }
+
+      it { is_expected.to eq("runtime error") }
+    end
+
+    context "when value is something else" do
+      let(:value) { Fear.try { raise StandardError } }
+
+      it { is_expected.to eq("something else") }
+    end
+  end
+end