fear 1.0.0 → 2.0.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) { Fear.right('value') }
+    let(:right) { Fear.right("value") }
   end
 
-  let(:right) { Fear.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(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(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(Fear.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(Fear.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(Fear.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,45 +80,45 @@ 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) { Fear.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(Fear.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
+  describe "#match" do
+    context "matched" do
       subject do
         right.match do |m|
           m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
@@ -125,15 +127,15 @@ RSpec.describe Fear::Right do
         end
       end
 
-      it { is_expected.to eq('Right: value') }
+      it { is_expected.to eq("Right: value") }
     end
 
-    context 'nothing matched and no else given' do
+    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' }
+            m.left { |_| "noop" }
           end
         end
       end
@@ -141,7 +143,7 @@ RSpec.describe Fear::Right do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         right.match do |m|
           m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
@@ -153,31 +155,9 @@ RSpec.describe Fear::Right do
     end
   end
 
-  describe '#to_s' do
+  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,71 +1,83 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Some do
   it_behaves_like Fear::RightBiased::Right do
-    let(:right) { Fear.some('value') }
+    let(:right) { Fear.some("value") }
   end
 
   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(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(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
+  describe "#blank?" do
+    subject { some.blank? }
+    it { is_expected.to eq(false) }
+  end
+
+  describe "#present?" do
+    subject { some.present? }
+    it { is_expected.to be_truthy }
+  end
+
+  describe "#match" do
+    context "matched" do
       subject do
         some.match do |m|
           m.some(->(x) { x > 2 }) { |x| x * 2 }
-          m.none { 'noop' }
+          m.none { "noop" }
         end
       end
 
       it { is_expected.to eq(84) }
     end
 
-    context 'nothing matched and no else given' do
+    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' }
+            m.none { "noop" }
           end
         end
       end
@@ -73,7 +85,7 @@ RSpec.describe Fear::Some do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         some.match do |m|
           m.none { |x| x * 2 }
@@ -85,31 +97,9 @@ RSpec.describe Fear::Some do
     end
   end
 
-  describe '#to_s' do
+  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
+    it { is_expected.to eq("#<Fear::Some get=42>") }
   end
 end

data/spec/fear/success_spec.rb

@@ -1,114 +1,116 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Success do
-  let(:success) { Fear.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 { raise '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 { raise '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 } } # rubocop: disable Style/InverseMethods
-      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 { raise '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
+  describe "#recover_with" do
     subject { success.recover_with { |v| Fear.success(v * 2) } }
     it { is_expected.to eq(success) }
   end
 
-  describe '#recover' do
+  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(Fear.right('value')) }
+    it { is_expected.to eq(Fear.right("value")) }
   end
 
-  describe '#match' do
-    context 'matched' do
+  describe "#match" do
+    context "matched" do
       subject do
         success.match do |m|
           m.success(->(x) { x.length > 2 }) { |x| x * 2 }
-          m.failure { 'noop' }
+          m.failure { "noop" }
         end
       end
 
-      it { is_expected.to eq('valuevalue') }
+      it { is_expected.to eq("valuevalue") }
     end
 
-    context 'nothing matched and no else given' do
+    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' }
+            m.failure { "noop" }
           end
         end
       end
@@ -116,7 +118,7 @@ RSpec.describe Fear::Success do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         success.match do |m|
           m.failure { |x| x * 2 }
@@ -128,31 +130,9 @@ RSpec.describe Fear::Success do
     end
   end
 
-  describe '#to_s' do
+  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

data/spec/fear/try/mixin_spec.rb

@@ -1,17 +1,33 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Try::Mixin do
   include Fear::Try::Mixin
 
-  describe 'Try()' do
-    context 'success' do
+  describe "Try()" do
+    context "success" do
       subject { Try { 4 / 2 } }
 
       it { is_expected.to eq(Fear::Success.new(2)) }
     end
 
-    context 'failure' do
+    context "failure" do
       subject { Try { 4 / 0 } }
 
       it { is_expected.to be_kind_of(Fear::Failure) }
     end
   end
+
+  describe "Success()" do
+    subject { Success(42) }
+
+    it { is_expected.to be_success_of(42) }
+  end
+
+  describe "Failure()" do
+    subject { Failure(error) }
+
+    let(:error) { StandardError.new }
+
+    it { is_expected.to be_failure_of(error) }
+  end
 end

data/spec/fear/try_api_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::TryApi do
+  describe "Fear.try" do
+    context "when success" do
+      subject { Fear.try { 42 } }
+
+      it { is_expected.to be_success_of(42) }
+    end
+
+    context "when failure" do
+      subject { Fear.try { raise RuntimeError } }
+
+      it { is_expected.to be_failure_of(RuntimeError) }
+    end
+
+    context "when low level error happened" do
+      subject(:try) { Fear.try { raise Exception } }
+
+      it { expect { try }.to raise_error(Exception) }
+    end
+  end
+end

data/spec/fear/try_pattern_match_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::TryPatternMatch do
-  context 'Success' do
+  context "Success" do
     let(:matcher) do
       described_class.new do |m|
         m.success(:even?.to_proc) { |x| "#{x} is even" }
@@ -8,15 +10,15 @@ RSpec.describe Fear::TryPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.success(4))).to eq('4 is even')
-      expect(matcher.call(Fear.success(3))).to eq('3 is odd')
+      expect(matcher.(Fear.success(4))).to eq("4 is even")
+      expect(matcher.(Fear.success(3))).to eq("3 is odd")
       expect do
-        matcher.call(Fear.failure(RuntimeError.new))
+        matcher.(Fear.failure(RuntimeError.new))
       end.to raise_error(Fear::MatchError)
     end
   end
 
-  context 'Failure' do
+  context "Failure" do
     let(:matcher) do
       described_class.new do |m|
         m.failure(RuntimeError) { |x| "#{x} is first" }
@@ -25,10 +27,10 @@ RSpec.describe Fear::TryPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.failure(RuntimeError.new))).to eq('RuntimeError is first')
-      expect(matcher.call(Fear.failure(StandardError.new))).to eq('StandardError is second')
+      expect(matcher.(Fear.failure(RuntimeError.new))).to eq("RuntimeError is first")
+      expect(matcher.(Fear.failure(StandardError.new))).to eq("StandardError is second")
       expect do
-        matcher.call(Fear.success(44))
+        matcher.(Fear.success(44))
       end.to raise_error(Fear::MatchError)
     end
   end