fear 0.9.0 → 1.2.0

data/spec/fear/right_spec.rb

@@ -1,76 +1,78 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Right do
   it_behaves_like Fear::RightBiased::Right do
-    let(:right) { Right('value') }
+    let(:right) { Fear.right("value") }
   end
 
-  let(:right) { Right('value') }
+  let(:right) { Fear.right("value") }
 
-  describe '#right?' do
+  describe "#right?" do
     subject { right }
     it { is_expected.to be_right }
   end
 
-  describe '#left?' do
+  describe "#left?" do
     subject { right }
     it { is_expected.not_to be_left }
   end
 
-  describe '#select_or_else' do
+  describe "#select_or_else" do
     subject { right.select_or_else(default, &predicate) }
 
-    context 'predicate evaluates to true' do
-      let(:predicate) { ->(v) { v == 'value' } }
+    context "predicate evaluates to true" do
+      let(:predicate) { ->(v) { v == "value" } }
       let(:default) { -1 }
       it { is_expected.to eq(right) }
     end
 
-    context 'predicate evaluates to false and default is a proc' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "predicate evaluates to false and default is a proc" do
+      let(:predicate) { ->(v) { v != "value" } }
       let(:default) { -> { -1 } }
-      it { is_expected.to eq(Left(-1)) }
+      it { is_expected.to eq(Fear.left(-1)) }
     end
 
-    context 'predicate evaluates to false and default is not a proc' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "predicate evaluates to false and default is not a proc" do
+      let(:predicate) { ->(v) { v != "value" } }
       let(:default) { -1 }
-      it { is_expected.to eq(Left(-1)) }
+      it { is_expected.to eq(Fear.left(-1)) }
     end
   end
 
-  describe '#select' do
+  describe "#select" do
     subject { right.select(&predicate) }
 
-    context 'predicate evaluates to true' do
-      let(:predicate) { ->(v) { v == 'value' } }
+    context "predicate evaluates to true" do
+      let(:predicate) { ->(v) { v == "value" } }
       it { is_expected.to eq(right) }
     end
 
-    context 'predicate evaluates to false' do
-      let(:predicate) { ->(v) { v != 'value' } }
-      it { is_expected.to eq(Left('value')) }
+    context "predicate evaluates to false" do
+      let(:predicate) { ->(v) { v != "value" } }
+      it { is_expected.to eq(Fear.left("value")) }
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject { right.reject(&predicate) }
 
-    context 'predicate evaluates to true' do
-      let(:predicate) { ->(v) { v == 'value' } }
-      it { is_expected.to eq(Left('value')) }
+    context "predicate evaluates to true" do
+      let(:predicate) { ->(v) { v == "value" } }
+      it { is_expected.to eq(Fear.left("value")) }
     end
 
-    context 'predicate evaluates to false' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "predicate evaluates to false" do
+      let(:predicate) { ->(v) { v != "value" } }
       it { is_expected.to eq(right) }
     end
   end
 
-  describe '#swap' do
+  describe "#swap" do
     subject { right.swap }
-    it { is_expected.to eq(Left('value')) }
+    it { is_expected.to eq(Fear.left("value")) }
   end
 
-  describe '#reduce' do
+  describe "#reduce" do
     subject do
       right.reduce(
         ->(left) { "Left: #{left}" },
@@ -78,40 +80,106 @@ RSpec.describe Fear::Right do
       )
     end
 
-    it { is_expected.to eq('Right: value') }
+    it { is_expected.to eq("Right: value") }
   end
 
-  describe '#join_right' do
-    context 'value is Either' do
+  describe "#join_right" do
+    context "value is Either" do
       subject { described_class.new(value).join_right }
-      let(:value) { Left('error') }
+      let(:value) { Fear.left("error") }
 
-      it 'returns value' do
+      it "returns value" do
         is_expected.to eq(value)
       end
     end
 
-    context 'value is not Either' do
-      subject { proc { described_class.new('35').join_right } }
+    context "value is not Either" do
+      subject { proc { described_class.new("35").join_right } }
 
-      it 'fails with type error' do
+      it "fails with type error" do
         is_expected.to raise_error(TypeError)
       end
     end
   end
 
-  describe '#join_left' do
-    context 'value is Either' do
+  describe "#join_left" do
+    context "value is Either" do
       subject { either.join_left }
-      let(:either) { described_class.new(Left('error')) }
+      let(:either) { described_class.new(Fear.left("error")) }
 
       it { is_expected.to eq(either) }
     end
 
-    context 'value is not Either' do
+    context "value is not Either" do
       subject { either.join_left }
-      let(:either) { described_class.new('result') }
+      let(:either) { described_class.new("result") }
       it { is_expected.to eq(either) }
     end
   end
+
+  describe "#match" do
+    context "matched" do
+      subject do
+        right.match do |m|
+          m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
+          m.right(->(x) { x.length > 2 }) { |x| "Right: #{x}" }
+          m.left(->(x) { x.length > 2 }) { |x| "Left: #{x}" }
+        end
+      end
+
+      it { is_expected.to eq("Right: value") }
+    end
+
+    context "nothing matched and no else given" do
+      subject do
+        proc do
+          right.match do |m|
+            m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
+            m.left { |_| "noop" }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context "nothing matched and else given" do
+      subject do
+        right.match do |m|
+          m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
+
+  describe "#to_s" do
+    subject { right.to_s }
+
+    it { is_expected.to eq('#<Fear::Right value="value">') }
+  end
+
+  describe "pattern matching" do
+    subject { Fear.xcase("Right(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
+
+    context "right of int" do
+      let(:var) { Fear.right(42) }
+
+      it { is_expected.to eq("matched 42") }
+    end
+
+    context "right of string" do
+      let(:var) { Fear.right("42") }
+
+      it { is_expected.to eq("nothing") }
+    end
+
+    context "not right" do
+      let(:var) { "42" }
+
+      it { is_expected.to eq("nothing") }
+    end
+  end
 end

data/spec/fear/some_spec.rb

@@ -1,52 +1,117 @@
-RSpec.describe Fear::Some do
-  include Fear::Option::Mixin
+# frozen_string_literal: true
 
+RSpec.describe Fear::Some do
   it_behaves_like Fear::RightBiased::Right do
-    let(:right) { Some('value') }
+    let(:right) { Fear.some("value") }
   end
 
-  subject(:some) { Some(42) }
+  subject(:some) { Fear.some(42) }
 
-  describe '#select' do
+  describe "#select" do
     subject { some.select(&predicate) }
 
-    context 'predicate evaluates to true' do
+    context "predicate evaluates to true" do
       let(:predicate) { ->(v) { v > 40 } }
       it { is_expected.to eq(some) }
     end
 
-    context 'predicate evaluates to false' do
+    context "predicate evaluates to false" do
       let(:predicate) { ->(v) { v < 40 } }
-      it { is_expected.to eq(None()) }
+      it { is_expected.to eq(Fear.none) }
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject { some.reject(&predicate) }
 
-    context 'predicate evaluates to true' do
+    context "predicate evaluates to true" do
       let(:predicate) { ->(v) { v > 40 } }
-      it { is_expected.to eq(None()) }
+      it { is_expected.to eq(Fear.none) }
     end
 
-    context 'predicate evaluates to false' do
+    context "predicate evaluates to false" do
       let(:predicate) { ->(v) { v < 40 } }
       it { is_expected.to eq(some) }
     end
   end
 
-  describe '#get' do
+  describe "#get" do
     subject { some.get }
     it { is_expected.to eq(42) }
   end
 
-  describe '#or_nil' do
+  describe "#or_nil" do
     subject { some.or_nil }
     it { is_expected.to eq(42) }
   end
 
-  describe '#empty?' do
+  describe "#empty?" do
     subject { some.empty? }
     it { is_expected.to eq(false) }
   end
+
+  describe "#match" do
+    context "matched" do
+      subject do
+        some.match do |m|
+          m.some(->(x) { x > 2 }) { |x| x * 2 }
+          m.none { "noop" }
+        end
+      end
+
+      it { is_expected.to eq(84) }
+    end
+
+    context "nothing matched and no else given" do
+      subject do
+        proc do
+          some.match do |m|
+            m.some(->(x) { x < 2 }) { |x| x * 2 }
+            m.none { "noop" }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context "nothing matched and else given" do
+      subject do
+        some.match do |m|
+          m.none { |x| x * 2 }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
+
+  describe "#to_s" do
+    subject { some.to_s }
+
+    it { is_expected.to eq("#<Fear::Some get=42>") }
+  end
+
+  describe "pattern matching" do
+    subject { Fear.xcase("Some(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
+
+    context "some of int" do
+      let(:var) { Fear.some(42) }
+
+      it { is_expected.to eq("matched 42") }
+    end
+
+    context "some of string" do
+      let(:var) { Fear.some("42") }
+
+      it { is_expected.to eq("nothing") }
+    end
+
+    context "not some" do
+      let(:var) { "42" }
+
+      it { is_expected.to eq("nothing") }
+    end
+  end
 end

data/spec/fear/success_spec.rb

@@ -1,93 +1,160 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Success do
-  let(:success) { Success('value') }
+  let(:success) { Fear.success("value") }
 
   it_behaves_like Fear::RightBiased::Right do
     let(:right) { success }
 
-    describe '#map', 'block fails' do
-      subject(:map) { right.map { fail 'unexpected error' } }
+    describe "#map", "block fails" do
+      subject(:map) { right.map { raise "unexpected error" } }
 
       it { is_expected.to be_kind_of(Fear::Failure) }
-      it { expect { map.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { map.get }.to raise_error(RuntimeError, "unexpected error") }
     end
 
-    describe '#flat_map', 'block fails' do
-      subject(:flat_map) { right.flat_map { fail 'unexpected error' } }
+    describe "#flat_map", "block fails" do
+      subject(:flat_map) { right.flat_map { raise "unexpected error" } }
 
       it { is_expected.to be_kind_of(Fear::Failure) }
-      it { expect { flat_map.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { flat_map.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#get' do
+  describe "#get" do
     subject { success.get }
-    it { is_expected.to eq('value') }
+    it { is_expected.to eq("value") }
   end
 
-  describe '#success?' do
+  describe "#success?" do
     subject { success }
     it { is_expected.to be_success }
   end
 
-  describe '#failure?' do
+  describe "#failure?" do
     subject { success }
     it { is_expected.not_to be_failure }
   end
 
-  describe '#or_else' do
-    subject { success.or_else { described_class.new('another value') } }
+  describe "#or_else" do
+    subject { success.or_else { described_class.new("another value") } }
     it { is_expected.to eq(success) }
   end
 
-  describe '#flatten' do
+  describe "#flatten" do
     subject { described_class.new(value).flatten }
 
-    context 'value is a Success' do
+    context "value is a Success" do
       let(:value) { described_class.new(42) }
       it { is_expected.to eq(described_class.new(42)) }
     end
 
-    context 'value is a Success of Success' do
+    context "value is a Success of Success" do
       let(:value) { described_class.new(described_class.new(42)) }
       it { is_expected.to eq(described_class.new(42)) }
     end
 
-    context 'value is a Success of Failure' do
+    context "value is a Success of Failure" do
       let(:failure) { Fear::Failure.new(RuntimeError.new) }
       let(:value) { described_class.new(failure) }
       it { is_expected.to eq(failure) }
     end
   end
 
-  describe '#select' do
-    context 'predicate holds for value' do
-      subject { success.select { |v| v == 'value' } }
+  describe "#select" do
+    context "predicate holds for value" do
+      subject { success.select { |v| v == "value" } }
       it { is_expected.to eq(success) }
     end
 
-    context 'predicate does not hold for value' do
-      subject { proc { success.select { |v| v != 'value' }.get } }
-      it { is_expected.to raise_error(Fear::NoSuchElementError, 'Predicate does not hold for `value`') }
+    context "predicate does not hold for value" do
+      subject { proc { success.select { |v| v != "value" }.get } }
+      it { is_expected.to raise_error(Fear::NoSuchElementError, "Predicate does not hold for `value`") }
     end
 
-    context 'predicate fails with error' do
-      subject { proc { success.select { fail 'foo' }.get } }
-      it { is_expected.to raise_error(RuntimeError, 'foo') }
+    context "predicate fails with error" do
+      subject { proc { success.select { raise "foo" }.get } }
+      it { is_expected.to raise_error(RuntimeError, "foo") }
     end
   end
 
-  describe '#recover_with' do
-    subject { success.recover_with { |v| Success(v * 2) } }
+  describe "#recover_with" do
+    subject { success.recover_with { |v| Fear.success(v * 2) } }
     it { is_expected.to eq(success) }
   end
 
-  describe '#recover' do
-    subject { success.recover { |v| v * 2 } }
+  describe "#recover" do
+    subject { success.recover { |m| m.case { |v| v * 2 } } }
     it { is_expected.to eq(success) }
   end
 
-  describe '#to_either' do
+  describe "#to_either" do
     subject { success.to_either }
-    it { is_expected.to eq(Right('value')) }
+    it { is_expected.to eq(Fear.right("value")) }
+  end
+
+  describe "#match" do
+    context "matched" do
+      subject do
+        success.match do |m|
+          m.success(->(x) { x.length > 2 }) { |x| x * 2 }
+          m.failure { "noop" }
+        end
+      end
+
+      it { is_expected.to eq("valuevalue") }
+    end
+
+    context "nothing matched and no else given" do
+      subject do
+        proc do
+          success.match do |m|
+            m.success(->(x) { x.length < 2 }) { |x| x * 2 }
+            m.failure { "noop" }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context "nothing matched and else given" do
+      subject do
+        success.match do |m|
+          m.failure { |x| x * 2 }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
+
+  describe "#to_s" do
+    subject { success.to_s }
+
+    it { is_expected.to eq('#<Fear::Success value="value">') }
+  end
+
+  describe "pattern matching" do
+    subject { Fear.xcase("Success(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
+
+    context "success of int" do
+      let(:var) { Fear.success(42) }
+
+      it { is_expected.to eq("matched 42") }
+    end
+
+    context "success of string" do
+      let(:var) { Fear.success("42") }
+
+      it { is_expected.to eq("nothing") }
+    end
+
+    context "not success" do
+      let(:var) { "42" }
+
+      it { is_expected.to eq("nothing") }
+    end
   end
 end