fear 1.0.0 → 1.1.0

data/spec/fear/some_spec.rb

@@ -1,71 +1,73 @@
+# 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 "#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 +75,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 +87,31 @@ 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>') }
+    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' } }
+  describe "pattern matching" do
+    subject { Fear.xcase("Some(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
 
-    context 'some of int' do
+    context "some of int" do
       let(:var) { Fear.some(42) }
 
-      it { is_expected.to eq('matched 42') }
+      it { is_expected.to eq("matched 42") }
     end
 
-    context 'some of string' do
-      let(:var) { Fear.some('42') }
+    context "some of string" do
+      let(:var) { Fear.some("42") }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
 
-    context 'not some' do
-      let(:var) { '42' }
+    context "not some" do
+      let(:var) { "42" }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
   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,31 @@ 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' } }
+  describe "pattern matching" do
+    subject { Fear.xcase("Success(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
 
-    context 'success of int' do
+    context "success of int" do
       let(:var) { Fear.success(42) }
 
-      it { is_expected.to eq('matched 42') }
+      it { is_expected.to eq("matched 42") }
     end
 
-    context 'success of string' do
-      let(:var) { Fear.success('42') }
+    context "success of string" do
+      let(:var) { Fear.success("42") }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
 
-    context 'not success' do
-      let(:var) { '42' }
+    context "not success" do
+      let(:var) { "42" }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
   end
 end

data/spec/fear/try/mixin_spec.rb

@@ -1,14 +1,16 @@
+# 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) }

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

data/spec/fear/utils_spec.rb

@@ -1,58 +1,60 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Utils do
-  describe '.assert_arg_or_block!' do
+  describe ".assert_arg_or_block!" do
     def assert_arg_or_block!(*args, &block)
       described_class.assert_arg_or_block!(:the_method, *args, &block)
     end
 
-    context 'block given, argument does not given' do
+    context "block given, argument does not given" do
       subject { proc { assert_arg_or_block! {} } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'argument given, block does not given' do
+    context "argument given, block does not given" do
       subject { proc { assert_arg_or_block!(42) } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'argument and block given at the same time' do
+    context "argument and block given at the same time" do
       subject { proc { assert_arg_or_block!(42) {} } }
 
-      it 'fails with argument error' do
+      it "fails with argument error" do
         is_expected.to raise_error(
           ArgumentError,
-          '#the_method accepts either one argument or block',
+          "#the_method accepts either one argument or block",
         )
       end
     end
 
-    context 'no argument and no block given' do
+    context "no argument and no block given" do
       subject { proc { assert_arg_or_block! } }
 
-      it 'fails with argument error' do
+      it "fails with argument error" do
         is_expected.to raise_error(
           ArgumentError,
-          '#the_method accepts either one argument or block',
+          "#the_method accepts either one argument or block",
         )
       end
     end
   end
 
-  describe 'assert_type!' do
-    context 'value is of the given type' do
+  describe "assert_type!" do
+    context "value is of the given type" do
       subject { proc { described_class.assert_type!(24, Integer) } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'value is not of the given type' do
+    context "value is not of the given type" do
       subject { proc { described_class.assert_type!(24, String) } }
 
-      it 'raises TypeError' do
+      it "raises TypeError" do
         is_expected.to raise_error(
           TypeError,
-          'expected `24` to be of String class',
+          "expected `24` to be of String class",
         )
       end
     end