fear 1.0.0 → 1.1.0

data/spec/fear/extractor_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Extractor do
-  describe '.register_extractor' do
-    Foo = Struct.new(:v1, :v2)
+  describe ".register_extractor" do
+    Foo = ::Struct.new(:v1, :v2)
     let(:matcher) do
       Fear.matcher do |m|
-        m.case(Fear['Foo(43, second : Integer)']) { |second| "43 and #{second}" }
-        m.case(Fear['Foo(42, second : Integer)']) { |second| "42 and #{second}" }
-        m.else { 'no match' }
+        m.case(Fear["Foo(43, second : Integer)"]) { |second| "43 and #{second}" }
+        m.case(Fear["Foo(42, second : Integer)"]) { |second| "42 and #{second}" }
+        m.else { "no match" }
       end
     end
 
@@ -13,46 +15,46 @@ RSpec.describe Fear::Extractor do
       Fear.case(Foo) { |foo| [foo.v1, foo.v2] }.lift
     end
 
-    context 'extractor not registered' do
-      it 'raise Fear::Extractor::ExtractorNotFound' do
+    context "extractor not registered" do
+      it "raise Fear::Extractor::ExtractorNotFound" do
         expect do
-          described_class.find_extractor('UnknownExtractor')
+          described_class.find_extractor("UnknownExtractor")
         end.to raise_error(Fear::Extractor::ExtractorNotFound)
       end
     end
 
-    context 'register by name' do
-      let(:extractor) { ->(*) { Fear.some('matched') } }
+    context "register by name" do
+      let(:extractor) { ->(*) { Fear.some("matched") } }
 
       before do
         described_class.register_extractor(
-          'ExtractorRegisteredByName',
-          'ExtractorRegisteredByName2',
+          "ExtractorRegisteredByName",
+          "ExtractorRegisteredByName2",
           extractor,
         )
       end
 
-      it 'returns extractor' do
-        expect(described_class.find_extractor('ExtractorRegisteredByName')).to eq(extractor)
-        expect(described_class.find_extractor('ExtractorRegisteredByName2')).to eq(extractor)
+      it "returns extractor" do
+        expect(described_class.find_extractor("ExtractorRegisteredByName")).to eq(extractor)
+        expect(described_class.find_extractor("ExtractorRegisteredByName2")).to eq(extractor)
       end
     end
 
-    context 'register by class' do
-      let(:extractor) { ->(*) { Fear.some('matched') } }
+    context "register by class" do
+      let(:extractor) { ->(*) { Fear.some("matched") } }
       ExtractorRegisteredByClass = Class.new
 
       before do
         described_class.register_extractor(
           ExtractorRegisteredByClass,
-          'ExtractorRegisteredByClass2',
+          "ExtractorRegisteredByClass2",
           extractor,
         )
       end
 
-      it 'returns extractor' do
-        expect(described_class.find_extractor('ExtractorRegisteredByClass')).to eq(extractor)
-        expect(described_class.find_extractor('ExtractorRegisteredByClass2')).to eq(extractor)
+      it "returns extractor" do
+        expect(described_class.find_extractor("ExtractorRegisteredByClass")).to eq(extractor)
+        expect(described_class.find_extractor("ExtractorRegisteredByClass2")).to eq(extractor)
       end
     end
   end

data/spec/fear/failure_spec.rb

@@ -1,155 +1,157 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Failure do
-  let(:exception) { RuntimeError.new('error') }
+  let(:exception) { RuntimeError.new("error") }
   let(:failure) { Fear.failure(exception) }
 
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { failure }
   end
 
-  describe '#exception' do
+  describe "#exception" do
     subject { failure.exception }
     it { is_expected.to eq(exception) }
   end
 
-  describe '#success?' do
+  describe "#success?" do
     subject { failure }
     it { is_expected.not_to be_success }
   end
 
-  describe '#failure?' do
+  describe "#failure?" do
     subject { failure }
     it { is_expected.to be_failure }
   end
 
-  describe '#get' do
+  describe "#get" do
     subject { proc { failure.get } }
-    it { is_expected.to raise_error(RuntimeError, 'error') }
+    it { is_expected.to raise_error(RuntimeError, "error") }
   end
 
-  describe '#or_else' do
-    context 'default does not fail' do
-      subject { failure.or_else { Fear::Success.new('value') } }
-      it { is_expected.to eq(Fear::Success.new('value')) }
+  describe "#or_else" do
+    context "default does not fail" do
+      subject { failure.or_else { Fear::Success.new("value") } }
+      it { is_expected.to eq(Fear::Success.new("value")) }
     end
 
-    context 'default fails with error' do
-      subject(:or_else) { failure.or_else { raise 'unexpected error' } }
+    context "default fails with error" do
+      subject(:or_else) { failure.or_else { raise "unexpected error" } }
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { or_else.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { or_else.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#flatten' do
+  describe "#flatten" do
     subject { failure.flatten }
     it { is_expected.to eq(failure) }
   end
 
-  describe '#select' do
-    subject { failure.select { |v| v == 'value' } }
+  describe "#select" do
+    subject { failure.select { |v| v == "value" } }
     it { is_expected.to eq(failure) }
   end
 
-  context '#recover_with' do
-    context 'block matches the error and does not fail' do
+  context "#recover_with" do
+    context "block matches the error and does not fail" do
       subject do
         failure.recover_with do |m|
           m.case(RuntimeError) { |error| Fear.success(error.message) }
         end
       end
 
-      it 'returns result of evaluation of the block against the error' do
-        is_expected.to eq(Fear::Success.new('error'))
+      it "returns result of evaluation of the block against the error" do
+        is_expected.to eq(Fear::Success.new("error"))
       end
     end
 
-    context 'block does not match the error' do
+    context "block does not match the error" do
       subject do
         failure.recover_with do |m|
           m.case(ZeroDivisionError) { Fear.success(0) }
         end
       end
 
-      it 'returns the same failure' do
+      it "returns the same failure" do
         is_expected.to eq(failure)
       end
     end
 
-    context 'block fails' do
-      subject(:recover_with) { failure.recover_with { raise 'unexpected error' } }
+    context "block fails" do
+      subject(:recover_with) { failure.recover_with { raise "unexpected error" } }
 
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { recover_with.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { recover_with.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  context '#recover' do
-    context 'block matches the error and does not fail' do
+  context "#recover" do
+    context "block matches the error and does not fail" do
       subject do
         failure.recover do |m|
           m.case(RuntimeError, &:message)
         end
       end
 
-      it 'returns Success of evaluation of the block against the error' do
-        is_expected.to eq(Fear.success('error'))
+      it "returns Success of evaluation of the block against the error" do
+        is_expected.to eq(Fear.success("error"))
       end
     end
 
-    context 'block does not match the error' do
+    context "block does not match the error" do
       subject do
         failure.recover do |m|
           m.case(ZeroDivisionError, &:message)
         end
       end
 
-      it 'returns the same failure' do
+      it "returns the same failure" do
         is_expected.to eq(failure)
       end
     end
 
-    context 'block fails' do
+    context "block fails" do
       subject(:recover) do
         failure.recover do
-          raise 'unexpected error'
+          raise "unexpected error"
         end
       end
 
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { recover.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { recover.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#to_either' do
+  describe "#to_either" do
     subject { failure.to_either }
     it { is_expected.to eq(Fear.left(exception)) }
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === failure }
 
-    context 'matches erectly' do
+    context "matches erectly" do
       let(:match) { Fear.failure(exception) }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
+    context "value does not match" do
       let(:match) { Fear.failure(ArgumentError.new) }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
+    context "matches by class" do
       let(:match) { Fear.failure(RuntimeError) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
+    context "does not matches by class" do
       let(:match) { Fear.failure(ArgumentError) }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '#match' do
-    context 'matched' do
+  describe "#match" do
+    context "matched" do
       subject do
         failure.match do |m|
           m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
@@ -158,15 +160,15 @@ RSpec.describe Fear::Failure do
         end
       end
 
-      it { is_expected.to eq('Error: error') }
+      it { is_expected.to eq("Error: error") }
     end
 
-    context 'nothing matched and no else given' do
+    context "nothing matched and no else given" do
       subject do
         proc do
           failure.match do |m|
             m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
-            m.success { 'noop' }
+            m.success { "noop" }
           end
         end
       end
@@ -174,7 +176,7 @@ RSpec.describe Fear::Failure 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
         failure.match do |m|
           m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
@@ -186,31 +188,31 @@ RSpec.describe Fear::Failure do
     end
   end
 
-  describe '#to_s' do
+  describe "#to_s" do
     subject { failure.to_s }
 
-    it { is_expected.to eq('#<Fear::Failure exception=#<RuntimeError: error>>') }
+    it { is_expected.to eq("#<Fear::Failure exception=#<RuntimeError: error>>") }
   end
 
-  describe 'pattern matching' do
-    subject { Fear.xcase('Failure(v : ArgumentError)') { 'matched' }.call_or_else(var) { 'nothing' } }
+  describe "pattern matching" do
+    subject { Fear.xcase("Failure(v : ArgumentError)") { "matched" }.call_or_else(var) { "nothing" } }
 
-    context 'failure of ArgumentError' do
+    context "failure of ArgumentError" do
       let(:var) { Fear.failure(ArgumentError.new) }
 
-      it { is_expected.to eq('matched') }
+      it { is_expected.to eq("matched") }
     end
 
-    context 'failure of RuntimeError' do
+    context "failure of RuntimeError" do
       let(:var) { Fear.failure(RuntimeError.new) }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
 
-    context 'not failure' do
-      let(:var) { '42' }
+    context "not failure" do
+      let(:var) { "42" }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
   end
 end

data/spec/fear/for_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::For do
-  context 'unary' do
-    context 'Some' do
+  context "unary" do
+    context "Some" do
       subject do
         Fear.for(Fear.some(2)) { |a| a * 2 }
       end
@@ -8,7 +10,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.some(4)) }
     end
 
-    context 'None' do
+    context "None" do
       subject do
         Fear.for(Fear.none) { |a| a * 2 }
       end
@@ -17,7 +19,7 @@ RSpec.describe Fear::For do
     end
   end
 
-  context 'arrays' do
+  context "arrays" do
     subject do
       Fear.for([1, 2], [2, 3], [3, 4]) do |a, b, c|
         a * b * c
@@ -27,14 +29,14 @@ RSpec.describe Fear::For do
     it { is_expected.to eq([6, 8, 9, 12, 12, 16, 18, 24]) }
   end
 
-  context 'ternary' do
+  context "ternary" do
     subject do
       Fear.for(first, second, third) do |a, b, c|
         a * b * c
       end
     end
 
-    context 'all Same' do
+    context "all Same" do
       let(:first) { Fear.some(2) }
       let(:second) { Fear.some(3) }
       let(:third) { Fear.some(4) }
@@ -42,7 +44,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.some(24)) }
     end
 
-    context 'first is None' do
+    context "first is None" do
       let(:first) { Fear.none }
       let(:second) { Fear.some(3) }
       let(:third) { Fear.some(4) }
@@ -50,7 +52,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'second is None' do
+    context "second is None" do
       let(:first) { Fear.some(2) }
       let(:second) { Fear.none }
       let(:third) { Fear.some(4) }
@@ -58,7 +60,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'last is None' do
+    context "last is None" do
       let(:first) { Fear.some(2) }
       let(:second) { Fear.some(3) }
       let(:third) { Fear.none }
@@ -66,7 +68,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'all Same in lambdas' do
+    context "all Same in lambdas" do
       let(:first) { proc { Fear.some(2) } }
       let(:second) { proc { Fear.some(3) } }
       let(:third) { proc { Fear.some(4) } }
@@ -74,28 +76,28 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Fear.some(24)) }
     end
 
-    context 'first is None in lambda, second is failure in lambda' do
+    context "first is None in lambda, second is failure in lambda" do
       let(:first) { proc { Fear.none } }
-      let(:second) { proc { raise 'kaboom' } }
+      let(:second) { proc { raise "kaboom" } }
       let(:third) { proc {} }
 
-      it 'returns None without evaluating second and third' do
+      it "returns None without evaluating second and third" do
         is_expected.to eq(Fear.none)
       end
     end
 
-    context 'second is None in lambda, third is failure in lambda' do
+    context "second is None in lambda, third is failure in lambda" do
       let(:first) { Fear.some(2) }
       let(:second) { proc { Fear.none } }
-      let(:third) { proc { raise 'kaboom' } }
+      let(:third) { proc { raise "kaboom" } }
 
-      it 'returns None without evaluating third' do
+      it "returns None without evaluating third" do
         is_expected.to eq(Fear.none)
       end
     end
   end
 
-  context 'refer to previous variable from lambda' do
+  context "refer to previous variable from lambda" do
     subject do
       Fear.for(first, second, third) do |_, b, c|
         b * c