fear 1.0.0 → 2.0.0

data/spec/fear/pattern_match_spec.rb

@@ -1,39 +1,7 @@
-RSpec.describe Fear::PatternMatch do
-  context 'extracting' do
-    let(:matcher) do
-      described_class.new do |m|
-        m.xcase('Date(year, 2, 29)', ->(year:) { year < 2000 }) do |year:|
-          "#{year} is a leap year before Millennium"
-        end
-        m.xcase('Date(year, 2, 29)') do |year:|
-          "#{year} is a leap year after Millennium"
-        end
-        m.case(Date) do |date|
-          "#{date.year} is not a leap year"
-        end
-      end
-    end
-
-    context 'before Millennium' do
-      subject { matcher.call(Date.parse('1996-02-29')) }
-
-      it { is_expected.to eq('1996 is a leap year before Millennium') }
-    end
+# frozen_string_literal: true
 
-    context 'after Millennium' do
-      subject { matcher.call(Date.parse('2004-02-29')) }
-
-      it { is_expected.to eq('2004 is a leap year after Millennium') }
-    end
-
-    context 'not leap' do
-      subject { matcher.call(Date.parse('2003-01-24')) }
-
-      it { is_expected.to eq('2003 is not a leap year') }
-    end
-  end
-
-  context 'else at the end' do
+RSpec.describe Fear::PatternMatch do
+  context "else at the end" do
     let(:matcher) do
       described_class.new do |m|
         m.case(Integer) { |x| "#{x} is int" }
@@ -42,27 +10,27 @@ RSpec.describe Fear::PatternMatch do
       end
     end
 
-    context 'Integer' do
-      subject { matcher.call(4) }
+    context "Integer" do
+      subject { matcher.(4) }
 
-      it { is_expected.to eq('4 is int') }
+      it { is_expected.to eq("4 is int") }
     end
 
-    context 'String' do
-      subject { matcher.call('4') }
+    context "String" do
+      subject { matcher.("4") }
 
-      it { is_expected.to eq('4 is str') }
+      it { is_expected.to eq("4 is str") }
     end
 
-    context 'Symbol' do
-      subject { matcher.call(:a) }
+    context "Symbol" do
+      subject { matcher.(:a) }
 
-      it { is_expected.to eq('a is something else') }
+      it { is_expected.to eq("a is something else") }
     end
   end
 
-  context 'else before other branches' do
-    subject { matcher.call(4) }
+  context "else before other branches" do
+    subject { matcher.(4) }
 
     let(:matcher) do
       described_class.new do |m|
@@ -71,11 +39,11 @@ RSpec.describe Fear::PatternMatch do
       end
     end
 
-    it { is_expected.to eq('4 is something else') }
+    it { is_expected.to eq("4 is something else") }
   end
 
-  context 'several else branches' do
-    subject { matcher.call(4) }
+  context "several else branches" do
+    subject { matcher.(4) }
 
     let(:matcher) do
       described_class.new do |m|
@@ -84,8 +52,8 @@ RSpec.describe Fear::PatternMatch do
       end
     end
 
-    it 'first one wins' do
-      is_expected.to eq('4 else 1')
+    it "first one wins" do
+      is_expected.to eq("4 else 1")
     end
   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/promise_spec.rb

@@ -1,93 +1,93 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Promise do
   let(:value) { 42 }
-  let(:error) { StandardError.new('something went wrong') }
+  let(:error) { StandardError.new("something went wrong") }
 
   def not_completed_promise
     Fear::Promise.new(executor: Concurrent::ImmediateExecutor.new)
   end
 
-  context 'not completed' do
-    it '#success! returns self' do
+  context "not completed" do
+    it "#success! returns self" do
       completed_promise = not_completed_promise.success!(value)
 
       expect(completed_promise).to eq completed_promise
     end
 
-    it '#success returns true' do
+    it "#success returns true" do
       completed = not_completed_promise.success(value)
 
       expect(completed).to be true
     end
 
-    it '#failure! returns self' do
+    it "#failure! returns self" do
       completed_promise = not_completed_promise.failure!(error)
 
       expect(completed_promise).to eq completed_promise
     end
 
-    it '#failure returns true' do
+    it "#failure returns true" do
       completed = not_completed_promise.failure(error)
 
       expect(completed).to be true
     end
 
-    it '#completed? returns true' do
+    it "#completed? returns true" do
       expect(not_completed_promise).not_to be_completed
     end
 
-    it '#future returns not completed future' do
+    it "#future returns not completed future" do
       future = not_completed_promise.to_future
 
       expect(future).not_to be_completed
     end
   end
 
-  context 'completed' do
+  context "completed" do
     def completed_promise
       not_completed_promise.success!(value)
     end
 
-    it '#success! fails with exception' do
+    it "#success! fails with exception" do
       expect do
         completed_promise.success!(value)
       end.to raise_exception(Fear::IllegalStateException)
     end
 
-    it '#success returns false' do
+    it "#success returns false" do
       completed = completed_promise.success(value)
 
       expect(completed).to be false
     end
 
-    it '#failure! fails with exception' do
+    it "#failure! fails with exception" do
       expect do
         completed_promise.failure!(error)
       end.to raise_exception(Fear::IllegalStateException)
     end
 
-    it '#failure returns false' do
+    it "#failure returns false" do
       completed = completed_promise.success(error)
 
       expect(completed).to be false
     end
 
-    it '#completed? returns true' do
+    it "#completed? returns true" do
       expect(completed_promise).to be_completed
     end
 
-    context '#future' do
-      subject(:future) do
-        completed_promise.to_future
-      end
+    context "#future" do
+      subject(:future) { Fear::Await.ready(promise.to_future, 0.01) }
 
-      it 'is completed' do
+      let(:promise) { Fear::Promise.new.success!(value) }
+
+      it "is completed" do
         expect(future).to be_completed
       end
 
-      it 'completed with value' do
-        future_value = future.value
-
-        expect(future_value).to eq Fear.some(Fear.success(value))
+      it "completed with value" do
+        expect(future.value).to be_some_of(Fear.success(value))
       end
     end
   end

data/spec/fear/right_biased/left.rb

@@ -1,85 +1,87 @@
+# frozen_string_literal: true
+
 RSpec.shared_examples Fear::RightBiased::Left do
-  describe '#include?' do
+  describe "#include?" do
     subject { left }
-    it { is_expected.not_to include('value') }
+    it { is_expected.not_to include("value") }
   end
 
-  describe '#get_or_else' do
-    context 'with block' do
-      subject { left.get_or_else { 'default' } }
+  describe "#get_or_else" do
+    context "with block" do
+      subject { left.get_or_else { "default" } }
 
-      it 'returns default value' do
-        is_expected.to eq('default')
+      it "returns default value" do
+        is_expected.to eq("default")
       end
     end
 
-    context 'with default argument' do
-      subject { left.get_or_else('default') }
+    context "with default argument" do
+      subject { left.get_or_else("default") }
 
-      it 'returns default value' do
-        is_expected.to eq('default')
+      it "returns default value" do
+        is_expected.to eq("default")
       end
     end
 
-    context 'with false argument' do
+    context "with false argument" do
       subject { left.get_or_else(false) }
 
-      it 'returns default value' do
+      it "returns default value" do
         is_expected.to eq(false)
       end
     end
 
-    context 'with nil argument' do
+    context "with nil argument" do
       subject { left.get_or_else(nil) }
 
-      it 'returns default value' do
+      it "returns default value" do
         is_expected.to eq(nil)
       end
     end
   end
 
-  describe '#each' do
+  describe "#each" do
     subject do
       proc do |block|
         expect(left.each(&block)).to eq(left)
       end
     end
 
-    it 'does not call the block' do
+    it "does not call the block" do
       is_expected.not_to yield_control
     end
   end
 
-  describe '#map' do
+  describe "#map" do
     subject { left.map(&:length) }
 
-    it 'returns self' do
+    it "returns self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#flat_map' do
+  describe "#flat_map" do
     subject { left.flat_map(&:length) }
 
-    it 'returns self' do
+    it "returns self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#to_option' do
+  describe "#to_option" do
     subject { left.to_option }
     it { is_expected.to eq(Fear::None) }
   end
 
-  describe '#any?' do
-    subject { left.any? { |v| v == 'value' } }
+  describe "#any?" do
+    subject { left.any? { |v| v == "value" } }
     it { is_expected.to eq(false) }
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === left }
 
-    context 'the same object' do
+    context "the same object" do
       let(:match) { left }
       it { is_expected.to eq(true) }
     end

data/spec/fear/right_biased/right.rb

@@ -1,141 +1,143 @@
+# frozen_string_literal: true
+
 RSpec.shared_examples Fear::RightBiased::Right do
-  describe '#include?' do
-    context 'contains value' do
-      subject { right.include?('value') }
+  describe "#include?" do
+    context "contains value" do
+      subject { right.include?("value") }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not contain value' do
-      subject { right.include?('another value') }
+    context "does not contain value" do
+      subject { right.include?("another value") }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '#get_or_else' do
-    context 'with block' do
-      subject { right.get_or_else { 'default' } }
+  describe "#get_or_else" do
+    context "with block" do
+      subject { right.get_or_else { "default" } }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
 
-    context 'with default argument' do
-      subject { right.get_or_else('default') }
+    context "with default argument" do
+      subject { right.get_or_else("default") }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
 
-    context 'with false argument' do
+    context "with false argument" do
       subject { right.get_or_else(false) }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
 
-    context 'with nil argument' do
+    context "with nil argument" do
       subject { right.get_or_else(nil) }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
   end
 
-  describe '#each' do
+  describe "#each" do
     subject do
       proc do |block|
         expect(right.each(&block)).to eq(right)
       end
     end
 
-    it 'calls the block with value' do
-      is_expected.to yield_with_args('value')
+    it "calls the block with value" do
+      is_expected.to yield_with_args("value")
     end
   end
 
-  describe '#or_else' do
-    it 'does not call block' do
+  describe "#or_else" do
+    it "does not call block" do
       expect { |probe| right.or_else(&probe) }.not_to yield_control
     end
 
-    it 'returns the same object' do
+    it "returns the same object" do
       expect(right.or_else { 42 }).to eql(right)
     end
   end
 
-  describe '#map' do
+  describe "#map" do
     subject { right.map(&:length) }
 
-    it 'perform transformation' do
+    it "perform transformation" do
       is_expected.to eq(described_class.new(5))
     end
   end
 
-  describe '#flat_map' do
-    context 'block returns neither left, nor right' do
+  describe "#flat_map" do
+    context "block returns neither left, nor right" do
       subject { proc { right.flat_map { 42 } } }
 
-      it 'fails with TypeError' do
+      it "fails with TypeError" do
         is_expected.to raise_error(TypeError)
       end
     end
 
-    context 'block returns RightBiased' do
+    context "block returns RightBiased" do
       subject { right.flat_map { |e| described_class.new("Result: #{e}") } }
 
-      it 'maps to block result' do
-        is_expected.to eq(described_class.new('Result: value'))
+      it "maps to block result" do
+        is_expected.to eq(described_class.new("Result: value"))
       end
     end
   end
 
-  describe '#to_option' do
+  describe "#to_option" do
     subject { right.to_option }
-    it { is_expected.to eq(Fear::Some.new('value')) }
+    it { is_expected.to eq(Fear::Some.new("value")) }
   end
 
-  describe '#any?' do
+  describe "#any?" do
     subject { right.any?(&predicate) }
 
-    context 'matches predicate' do
-      let(:predicate) { ->(v) { v == 'value' } }
+    context "matches predicate" do
+      let(:predicate) { ->(v) { v == "value" } }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not match predicate' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "does not match predicate" do
+      let(:predicate) { ->(v) { v != "value" } }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === right }
 
-    context 'matches erectly' do
-      let(:match) { described_class.new('value') }
+    context "matches erectly" do
+      let(:match) { described_class.new("value") }
       it { is_expected.to eq(true) }
     end
 
-    context 'the same object' do
+    context "the same object" do
       let(:match) { right }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
-      let(:match) { described_class.new('error') }
+    context "value does not match" do
+      let(:match) { described_class.new("error") }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
+    context "matches by class" do
       let(:match) { described_class.new(String) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
+    context "does not matches by class" do
       let(:match) { described_class.new(Integer) }
       it { is_expected.to eq(false) }
     end