fear 1.0.0 → 1.1.0

data/spec/fear/partial_function_spec.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::PartialFunction do
-  describe 'Fear.case()' do
-    context 'condition is extractor' do
+  describe "Fear.case()" do
+    context "condition is extractor" do
       subject do
-        Fear.xcase('[1, [2, second_of_second, *], 3, *rest]') do |second_of_second:, rest:|
+        Fear.xcase("[1, [2, second_of_second, *], 3, *rest]") do |second_of_second:, rest:|
           [second_of_second, rest]
         end
       end
@@ -12,25 +14,25 @@ RSpec.describe Fear::PartialFunction do
       it { is_expected.not_to be_defined_at([1, [1, 2, 3, 4], 4, 6, 7]) }
     end
 
-    context 'condition as symbol' do
+    context "condition as symbol" do
       subject { Fear.case(:even?) { |x| x } }
 
-      it 'matches against the same symbol' do
+      it "matches against the same symbol" do
         is_expected.to be_defined_at(:even?)
         is_expected.not_to be_defined_at(3)
       end
     end
 
-    context 'condition as Class' do
+    context "condition as Class" do
       subject { Fear.case(Integer) { |x| x } }
 
       it do
         is_expected.to be_defined_at(4)
-        is_expected.not_to be_defined_at('3')
+        is_expected.not_to be_defined_at("3")
       end
     end
 
-    context 'condition as Proc' do
+    context "condition as Proc" do
       subject { Fear.case(->(x) { x.even? }) { |x| x } }
 
       it do
@@ -39,19 +41,19 @@ RSpec.describe Fear::PartialFunction do
       end
     end
 
-    context 'multiple condition' do
+    context "multiple condition" do
       subject { Fear.case(Integer, :even?.to_proc, ->(x) { x % 3 == 0 }) { |x| x } }
 
       it do
         is_expected.to be_defined_at(12)
         is_expected.not_to be_defined_at(12.0)
-        is_expected.not_to be_defined_at('3')
+        is_expected.not_to be_defined_at("3")
         is_expected.not_to be_defined_at(3)
         is_expected.not_to be_defined_at(4)
       end
     end
 
-    context 'multiple condition 2' do
+    context "multiple condition 2" do
       subject { Fear.case(Integer, 4) { |x| x } }
 
       it do
@@ -61,124 +63,124 @@ RSpec.describe Fear::PartialFunction do
     end
   end
 
-  describe '#lift' do
+  describe "#lift" do
     let(:lifted) { partial_function.lift }
 
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
 
-    context 'defined' do
-      subject { lifted.call(2) }
+    context "defined" do
+      subject { lifted.(2) }
 
       it { is_expected.to eq(Fear::Some.new(2)) }
     end
 
-    context 'not defined' do
-      subject { lifted.call(0) }
+    context "not defined" do
+      subject { lifted.(0) }
 
       it { is_expected.to eq(Fear::None) }
     end
   end
 
-  describe '#defined_at?' do
+  describe "#defined_at?" do
     let(:partial_function) { Fear.case(->(v) { v == 42 }) {} }
 
-    it 'defined at' do
+    it "defined at" do
       expect(partial_function.defined_at?(42)).to eq(true)
     end
 
-    it 'not defined at' do
+    it "not defined at" do
       expect(partial_function.defined_at?(24)).to eq(false)
     end
   end
 
-  describe '#call' do
+  describe "#call" do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x } }
 
-    context 'defined' do
-      subject { partial_function.call(2) }
+    context "defined" do
+      subject { partial_function.(2) }
 
       it { is_expected.to eq(2) }
     end
 
-    context 'not defined' do
-      subject { -> { partial_function.call(0) } }
+    context "not defined" do
+      subject { -> { partial_function.(0) } }
 
-      it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 0') }
+      it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
 
-    context 'defined and condition is extractor' do
-      subject { partial_function.call([1, 2, 3, 4, 5]) }
+    context "defined and condition is extractor" do
+      subject { partial_function.([1, 2, 3, 4, 5]) }
 
       let(:partial_function) do
-        Fear.xcase('[1, second, 3, *rest]') { |second:, rest:| [second, rest] }
+        Fear.xcase("[1, second, 3, *rest]") { |second:, rest:| [second, rest] }
       end
 
       it { is_expected.to eq([2, [4, 5]]) }
     end
   end
 
-  describe '#to_proc', '#call' do
+  describe "#to_proc", "#call" do
     let(:partial_function) { Fear.case(->(v) { v != 0 }) { |x| 4 / x }.to_proc }
 
-    context 'defined' do
-      subject { partial_function.call(2) }
+    context "defined" do
+      subject { partial_function.(2) }
 
       it { is_expected.to eq(2) }
     end
 
-    context 'not defined' do
-      subject { -> { partial_function.call(0) } }
+    context "not defined" do
+      subject { -> { partial_function.(0) } }
 
-      it { is_expected.to raise_error(Fear::MatchError, 'partial function not defined at: 0') }
+      it { is_expected.to raise_error(Fear::MatchError, "partial function not defined at: 0") }
     end
   end
 
-  describe '#call_or_else' do
+  describe "#call_or_else" do
     let(:default) { ->(x) { "division by #{x} impossible" } }
     let(:partial_function) { Fear.case(->(x) { x != 0 }) { |x| 4 / x } }
 
-    context 'defined' do
+    context "defined" do
       subject { partial_function.call_or_else(2, &default) }
 
       it { is_expected.to eq(2) }
     end
 
-    context 'not defined' do
+    context "not defined" do
       subject { partial_function.call_or_else(0, &default) }
 
-      it { is_expected.to eq('division by 0 impossible') }
+      it { is_expected.to eq("division by 0 impossible") }
     end
   end
 
-  describe '#and_then' do
+  describe "#and_then" do
     let(:partial_function) { Fear.case(->(v) { v == 42 }) {} }
     let(:and_then) { ->(x) { x } }
 
-    context 'block given, arguments not given' do
+    context "block given, arguments not given" do
       subject { -> { partial_function.and_then(&and_then) } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'block given, argument given' do
+    context "block given, argument given" do
       subject { -> { partial_function.and_then(and_then, &and_then) } }
 
       it { is_expected.to raise_error(ArgumentError) }
     end
 
-    context 'block given, arguments given' do
+    context "block given, arguments given" do
       subject { -> { partial_function.and_then(and_then, 42, &and_then) } }
 
       it { is_expected.to raise_error(ArgumentError) }
     end
 
-    context 'block not given, arguments not given' do
+    context "block not given, arguments not given" do
       subject { -> { partial_function.and_then } }
 
       it { is_expected.to raise_error(ArgumentError) }
     end
 
-    context 'block net given, arguments given' do
+    context "block net given, arguments given" do
       subject { -> { partial_function.and_then(and_then) } }
 
       it { is_expected.not_to raise_error }

data/spec/fear/pattern_match_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::PatternMatch do
-  context 'extracting' do
+  context "extracting" do
     let(:matcher) do
       described_class.new do |m|
-        m.xcase('Date(year, 2, 29)', ->(year:) { year < 2000 }) do |year:|
+        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:|
+        m.xcase("Date(year, 2, 29)") do |year:|
           "#{year} is a leap year after Millennium"
         end
         m.case(Date) do |date|
@@ -14,26 +16,26 @@ RSpec.describe Fear::PatternMatch do
       end
     end
 
-    context 'before Millennium' do
-      subject { matcher.call(Date.parse('1996-02-29')) }
+    context "before Millennium" do
+      subject { matcher.(Date.parse("1996-02-29")) }
 
-      it { is_expected.to eq('1996 is a leap year before Millennium') }
+      it { is_expected.to eq("1996 is a leap year before Millennium") }
     end
 
-    context 'after Millennium' do
-      subject { matcher.call(Date.parse('2004-02-29')) }
+    context "after Millennium" do
+      subject { matcher.(Date.parse("2004-02-29")) }
 
-      it { is_expected.to eq('2004 is a leap year after Millennium') }
+      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')) }
+    context "not leap" do
+      subject { matcher.(Date.parse("2003-01-24")) }
 
-      it { is_expected.to eq('2003 is not a leap year') }
+      it { is_expected.to eq("2003 is not a leap year") }
     end
   end
 
-  context 'else at the end' do
+  context "else at the end" do
     let(:matcher) do
       described_class.new do |m|
         m.case(Integer) { |x| "#{x} is int" }
@@ -42,27 +44,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 +73,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 +86,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/promise_spec.rb

@@ -1,90 +1,92 @@
+# 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
+    context "#future" do
       subject(:future) do
         completed_promise.to_future
       end
 
-      it 'is completed' do
+      it "is completed" do
         expect(future).to be_completed
       end
 
-      it 'completed with value' do
+      it "completed with value" do
         future_value = future.value
 
         expect(future_value).to eq Fear.some(Fear.success(value))